Java_基础1

Java_基础1面向过程:适合简单,不需要协作的事务。 面向对象:宏观上使用面向对象把握,微观上处理任然是面向过程。 Java虚拟机的内存可以分为三个区域: 栈Stack,堆heap,方法区method area 栈的特点:方法执行的内存模型,每个方法被调用都会创建一个栈帧(储存局部变量,操作数,方法出口等); J

Java_基础1"

面向过程:适合简单,不需要协作的事务。
面向对象:宏观上使用面向对象把握,微观上处理任然是面向过程。

Java虚拟机的内存可以分为三个区域: 栈Stack,堆heap,方法区method area
  栈的特点:方法执行的内存模型,每个方法被调用都会创建一个栈帧(储存局部变量,操作数,方法出口等);
    JVM为每个线程创建一个独立的栈,用于存放该线程执行方法的信息;
    栈属于线程私有,不能实现线程间的共享;
    栈是由系统自动分配,速度快,栈是一个连续的内存空间。
  堆的特点
    用于存储创建好的对象和数组;
    JVM只有一个堆,被所有线程共享;
    堆是一个不连续的内存空间,分配灵活,速度慢;
  方法区:
    实际也是堆,只是用于储存类,常量相关的信息;

构造器:
  通过new关键字调用;
  构造器虽然有返回值,但是不能定义返回值类型,不能再构造器里使用return返回某个值
  如果我们没有定义构造器,则编译器会自动定义一个无参的构造函数。
  构造器的方法名必须和类名一致。

垃圾回收机制:
  发现无用的对象;
  回收无用对象占用的空间;
  两个方法: 引用计算法+引用可达法;
  通用的垃圾回收机制:
    年轻代:Eden
    年老代:Tenured
    持久代:Perm

对象创建的过程和this的本质:
创建对象:
1. 分配对象空间,并将对象成员变量初始化为0或空
2. 执行属性值的显式初始化;
3. 执行构造方法;
4. 返回对象的地址给相关的变量;
this的本质就是”创建好的对象的地址“;
1.this不能用于static方法中;
2. 在程序产生二义性之处,应使用this来指明当前对象,普通方法中,this总是指向调用该方法的对象。

Static关键字:静态的
类变量的生命周期和类相同。
static修饰的成员变量和方法,从属于类。 普通变量和方法从属于对象。

Java参数传值机制:
传递的是值的副本,所以传值不会影响原参数。

Java的包package机制:
  包对于类,就相当于文件夹对于文件的作用。
  包名:域名倒着写即可,再加上模块名,便于内部管理内。
  写项目有时要加包,不要使用默认包。

继承,封装,多态:
  java只有单继承;

方法的重写:
子类重写父类的方法:

方法的重载:
  就是不同的方法,但是名称相同。
  方法名相同,参数不同,构成重载;参数类型不同,构成重载;参数顺序不同,构成重载;
  只有 返回值不同,不构成重载;只有参数名称不同,不构成重载。

package Packagetest;

public class ExtendTest {
    public static void main(String[]args){
        Student stu=new Student();
        stu.name="spencer";
        stu.height=185;
        stu.major="logistics";
        stu.rest();
        
        Student stu2=new Student("alex",20,"coder");
        System.out.println(stu2 instanceof Student);
    }
}

class person{
    String name;
    int height;
    
    public void rest() {
        System.out.println("人类");
    }
}

class Student extends person{
    String major;
    
    public void study(){
        System.out.println("学习");
    }


    public Student(String name,int height,String major) {
        this.name =name;
        this.height=height;
        this.major=major;
    }
    
    public Student() {
        
    }
}

 

递归: 自己调用自己
  1. 定义递归头:如果没有这个就会进入死循环。
  2. 定义递归体:什么时候需要调用自身方法。

  Object类中定义有Public String toString()方法,其返回值是String类型。
  Object类中定义有:Public boolean equals(object obj)方法,提供定义“对象内容相等”的逻辑。
  在eclipse中右键souce,可以自动重写;

package Packagetest;

public class ObjectTest {
    public static void main(String[]args) {
    //    Object obj;
        ObjectTest to =new ObjectTest();
        System.out.println(to.toString());
        
        Person01 p1=new Person01("spencer",28);
        System.out.println(p1.toString());
    }
     public String toString() {
         return "object 测试";
     }
}

class Person01{
    String name;
    int age;
    
    @Override
    public String toString() {
        return name+ "年龄" +age;
        
    }
    public Person01(String name,int age){
        this.name = name;
        this.age=age;
    }
}

 

Super关键字
  是直接父类对象的引用, 可以通过super访问父类中被子类覆盖的方法或属性;

package Packagetest;

public class SuperTest {
    public static void main(String[]args) {
        new ChildClass().f();
        
    }
}

class FatherClass{
    public int value;
    public void f() {
        value=100;
        System.out.println("fatherclass.value="+value);
    }
}

class ChildClass extends FatherClass{
    public int value;
    
    public void f() {
        super.f(); //调用父类对象的普通方法,如果直接使用,f()是子类的value,加super是父类的value
        value=101;
        System.out.println("childclass.value="+value);
        System.out.println(value);
        System.out.println(super.value);//调用父类对象的成员变量
    }
}
package Packagetest;

public class SuperTest02 {
    public static void main(String[]args) {
        System.out.println("开始创建一个childclass对象");
        new ChildClass1();
    }
}

class FatherClass1{
    public FatherClass1() {
        System.out.println("创建fatherclass");
        
    }
}

class ChildClass1 extends FatherClass1{
    public ChildClass1() {
        //super(); super会自动创建
        System.out.println("创建childclass");
    }
}

 

静态初始化:
  1. 先上溯到object类,先执行object的静态初始化模块,再向下执行之类的静态初始化块,直到类的静态初始化模块为止。
  2. 同样的,构造方法执行顺序和上面的顺序一样。 构造方法的第一句总是super();

封装:
  private:只有自己类能访问;
  default:只有同一个包的类能访问;
  protected:可以被同一个包的类以及其他包中的子类访问;
  public:可以被改项目在所有包中的所有类访问;

类的属性的处理:
  1. 一般使用private,int,String,boolean等,外部必须要通过set方法和get方法来设置;

多态: 同一个方法的调用,对象的不同,会产生不同的行为。
  1. 方法的多态,而不是属性的多态,属性没有多态;
  2. 三个必要条件:继承,方法重写,父类引用指向子类对象;
  3. 父类引用指向子类对象;

final关键字:
  1. 修饰常量,不能更改;
  2. 修饰方法,不能重写,但可以重载;
  3. 修饰类,子类不能继承。

数组:相同类型数据的有序集合。
  1.数组的声明:type[] 变量名;string[] arr02; 分配空间:int[] arr01= new int[10];
  2. 数组的初始化:静态,动态和默认三种方式;
  3.数组的遍历:for each循环==>读取数组或集合中的所有元素;

package Packagetest;

public class EqualsTest {
    public static void main(String[]args) {
        
        User u1 = new User(12345,"spencer","xxxx");
        User u2 = new User(23456,"alex","ccccc");
        //用id判断是否是同一人
        System.out.println(u1==u2);
        System.out.println(u1.equals(u2));
    }
}


class User{
    int id;
    String name;
    String pwd;
    
    public User(int id, String name, String pwd) {
        super();
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    //右键souce自动生成,string类也可以;
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (id != other.id)
            return false;
        return true;
    }
}

 

今天的文章Java_基础1分享到此就结束了,感谢您的阅读,如果确实帮到您,您可以动动手指转发给其他人。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/55413.html

(0)
编程小号编程小号
上一篇 2023-08-27
下一篇 2023-08-27

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注