Java基础第三章

一、面向对象的思想

（1）封装性

（2）继承性

（3）多态性

二、类与对象

1.类的定义：一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物

public class ClassName {
	//成员变量
	//成员方法
    //构造方法：是特殊的成员方法
}

2.对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为

//创建对象：
类名 对象名 = new 类名();
-------------------------
类名 对象名称 = null;
对象名称 = new 类名（）；

//创建对象后，使用对象来访问类中的某个属性或方法：
对象名.成员变量；
对象名.成员方法()；
----------------------------------------------
eg:
class Student{
int age;
void read(){
         System.out.println("我的年龄是"+age);
}
}
class main{
    public static void main(String[] args){
    Student s1 = new Student();//创建对象s1
    s1.age = 16;
    s1.read;
}
}

3.访问控制：Java提供了四种主要的访问修饰符，每种修饰符控制不同的访问级别：

• public：公开访问，任何类都可以访问
• protected：受保护访问，同一个包中的类和所有子类可以访问
• default（无修饰符）：包级访问，同一个包中的类可以访问
• private：私有访问，只有同一个类中的成员可以访问

三、封装性：为了隐藏数据和接口明确

1.封装的实现：（1）使用访问修饰符

·                        （2）使用getter或setter方法

public class Person {
// 使用private修饰符隐藏属性
private String name;
private int age;
// 提供公共的getter方法
public String getName() {
    return name;
}
// 提供公共的setter方法
public void setName(String name) {
    this.name = name;
}
// 类似地，为age属性提供getter和setter方法
public int getAge() {
    return age;
}
public void setAge(int age) {
if (age >= 0) {
    this.age = age;
} 
else {
    System.out.println("Age cannot be negative!");
    }
}
}

四、构造方法

1.构造方法：

（1）构造方法的名称必须与类名一致。
（2）构造方法名称前不能有任何返回值类型的声明。
（3）不能在构造方法中使用return返回一个值，但可以单独写return语句作为方法的结束。

class Student{
    public Student() {
        System.out.println("构造方法");
    }
}
public class main {
    public static void main(String[] args) {
        System.out.println("声明对象...");
        Student stu = null;           		/
        System.out.println("实例化对象...");
        stu = new Student();     			
    }
}

2.构造方法的重载：在一个类中可以定义多个构造方法，但是需要每个构造方法的参数类型或参数个数不同

class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String n) {
        name = n;
        System.out.println("一个参数的构造方法");
    }

    public Student(String n, int a) {
        name = n;
        age = a;
        System.out.println("两个参数的构造方法");//构造方法的重载参数要不同
    }

    public void read() {
        System.out.println("我是:" + name + ",年龄:" + age);
    }
}

public class main {
    public static void main(String[] args){
        Student stu1=new Student("李");
        Student stu2=new Student("张",16)；
        stu1.read();
        stu2.read();

    }
}

五、this关键字

1.this关键字：

（1）使用this关键字调用本类属性

（2）使用this关键字调用成员方法

（3）使用this关键字调用本类构造方法

class Student {
    private String name;
    private int age;
    public Student(String name,int age) {
        this.name = name;//使用this关键字调用本类的属性
        this.age = age;
    }
    public void read(){
        System.out.println("我是"+name+"，我的年龄是"+age);

    }
    public void readagain(){
    this.read();//用this调用成员方法
    }
}
public class main {
    public static void main(String[] args) {
        Student stu = new Student("张三", 18);
        System.out.println(stu.read());

    }
}

六、代码块

1.普通代码块：就是用{}括号括起来的一段代码

2.构造块：

class Student {
    String name;
    {
        System.out.println("构造代码块");
    }
    public Student () {
        System.out.println("调用了无参的构造方法");
    }
    public Student (String name,int age) {
        this();               
        this.name = name;
        this.age = age;
    }
    public String read(){
        return "我是:"+name+",年龄:"+age;
    }
}
public class Example03 {
    public static void main(String[] args) {
        Student stu = new Student("张三",18);   
        System.out.println(stu.read());
    }
}

七、static关键字

1.静态属性：使用static修饰属性，则该属性称为静态属性

                     静态属性可以使用类名直接访问

类名.属性名

2.静态方法：

类名.方法

3.静态代码块：用static关键字修饰的代码块称为静态代码块