一、类与对象
类的定义：类是对一类事物的描述，是抽象的，是一个模板，是一种设计图纸；
对象的定义：对象是一类事物的实例，是具体的，是一个实体，是根据设计图纸生产出来的；
定义类的语法：
public class 类名{
//定义属性部分
属性1的类型 属性1;
属性2的类型 属性2;
......
//定义方法部分
方法1;
方法2;
......
}类名的规范：类名的第一个字母大写、类名尽量使用字母、类名要见名知意、不要使用关键字
定义对象的语法：
//对象名 = new 类名();
Person p1 = new Person();给属性赋值和调用类中的方法
调用属性：对象名.属性名
调用方法：对象名.方法名()
例：
public class Person{
int age;
protected void say(){
System.out.println("天啊,我的年齡是:" + age);
}
public static void main(String[] args) {
Person p1 = new Person(); //创建Person类的对象
p1.age=20; //调用属性,给属性赋值
p1.say(); //调用方法
}
}二、构造方法
构造方法的细节： 1.方法名必须和类名相同
2.没有具体的返回值，没有返回值类型，连void都没有、
3.如果没有定义构造方法，系统默认提供一个无参构造方法
public 类名(){
}4.如果定义了有构造方法，系统不会提供默认的无参构造方法
构造方法的重载：与普通方法的重载一样
例：
public class Dog {
String name; //名字
String type; //品种
int age; //年龄
public Dog(String name, String type, int age) {
this.name = name;
this.type = type;
this.age = age;
System.out.println("构造方法1执行了");
}
public Dog() {
System.out.println("构造方法2执行了");
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
System.out.println("构造方法3执行了");
}
public static void main(String[] args) {
Dog d1 = new Dog(); //这个调用Dog() 的构造方法
Dog d2 = new Dog("旺财",2); //这个调用Dog(String name, int age) 的构造方法
Dog d3 = new Dog("来福","泰迪",3);
//这个调用Dog(String name, String type, int age) 的构造方法
}
}三、关键字
this关键字：指代当前对象
this关键字主要有三个应用：
1.this调用本类中的属性，也就是类中的成员变量；
2.this调用本类中的其他方法；
3.this调用本类中的其他构造方法，调用时要放在构造方法的首行；
应用一：引用成员变量、引用本类其他方法
public class Student {
String name; // 定义一个成员变量name
public void setName(String name) { // 定义一个参数(局部变量)name
this.name = name; // 这个this一定不能省略，将局部变量的值传递给成员变量
}
public void fun(){
this.setName("张三"); // //这个this可以省略,可以写成setName(“张三”);调用setName()的方法
}
}应用二：调用类的构造方法
public class Student { // 定义一个类，类的名字为student。
public Student() { // 定义一个方法，名字与类相同故为构造方法
this("Hello"); // 通过this()来调用Student(String name)构造方法
System.out.println("构造方法执行了");
}
public Student(String name) { // 定义一个带形式参数的构造方法
}
}static关键字：是一个修饰符，用于修改类的成员（变量、方法或块）
1.静态属性是被static修饰的成员变量
2.静态属性是属于类的，不属于对象的，所以静态属性也称为类属性
3.静态属性可以通过类名.静态属性名的方式访问，也可以通过对象.静态属性名的方式访问
4.静态属性的数据是共享的，被所有对象所共享
静态方法：
1.静态方法是被static修饰的成员方法
2.静态方法是属于类的，不属于对象的，所以静态方法也称为类方法
3.静态方法中无this关键字，因为静态方法中不需要this，因为静态方法中只能访问静态成员(静态方法和静态属性)
4.静态方法可以通过类名.静态方法名的方式访问，也可以通过对象.静态方法名的方式访问
静态代码块：
1.静态代码块是在类加载时执行，且只执行一次
2.静态代码块中只能访问静态成员(静态方法和静态属性)
3.静态代码块的作用：用来给类进行初始化
同类中先执顺序：行静态代码，然后执行构造方法（无参，有参），最后执行其他方法
final关键字：用于修饰类、属性和方法
四、封装
什么是封装：封装的主要目的是将数据（成员变量）和操作这些数据的方法组合在一起，并隐藏对象的内部实现细节。
封装的目的：封装的主要目的是保护数据不被外界直接访问和修改，从而提高代码的可靠性和安全性。
封装的实现
1.使用访问修饰符
private：私有成员只能被本类中的方法访问
protected：受保护的成员可以被本类、子类以及同一个包中的其他类访问
public：公共成员，可以被所有类访问
2.提供getter和setter方法
getter方法用于获取私有成员的值，通常是无参数的方法，返回私有成员的值
setter方法用于设置私有成员的值，通常接收一个参数，用来更新私有成员的值
例：
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void showInfo(){
this.setName("无名氏");
age = 21;
}
}public class TestPerson1 {
public static void main(String[] args) {
Person p1 = new Person();
//p1.setName()可以访问,因为setName是public
p1.setName("张三");
//p1.age不能访问,因为age是private的
//p1.age=21; System.out.println(p1.getName());
}
}五、继承
什么是继承：继承是面向对象编程的一个核心概念，它允许一个类（子类）从另一个类（父类）中获取属性和行为。通过继承，子类可以重用父类的代码，并且还可以扩展自己的功能。
类的继承格式：class 子类 extends 父类 { }
例：
Person类:
public class Person {
String name;
int age;
}public class Student extends Person {
String school;
}测试类：
public class TestPersonStudentDemo {
public static void main(String[] args) {
Student s = new Student();
s.name = "张三"; // 访问 Person 类中的 name 属性并赋值
s.age = 25; // 访问 Person 类中的 age 属性并赋值
s.school = "北京"; // 访问 Student 类中的 school 属性并赋值
System.out.println("姓名：" + s.name + "，年龄：" + s.age + "，学校：" + s.school);
}
}测试结果：姓名：张三，年龄：25，学校：北京
继承条件下构造方法的调用
例：
public class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name; //父类的构造方法
this.age = age;
}
}public class Student extends Person {
String school;
public Student(){ //子类的构造方法
System.out.println("子类Student的构造方法");
}
}public class TestPersonStudentDemo {
public static void main(String[] args) {
Student s = new Student();
}
}此时编译运行，程序出错
原因：在Person类中提供了一个有参构造方法，但没有明确写出无参构造方法
解决方法：由于实例化子类对象时找不到父类中无参构造方法，所以程序出现了错误，而只要在
public class Person {
String name;
int age;
//推荐:在手动添加的有参的构造方法时,要手动添加一个无参的构造方法
public Person(){
} //在父类添加一个无参的构造方法,什么也不做
public Person(String name, int age) { //父类的构造方法
this.name = name;
this.age = age;
}
}super关键字：指代继承的父类、超类、基类
特点：可以调用父类的属性和方法 格式：super.父类中的属性；
可以调用父类的构造方法但是必须放在第一行 格式： super父类中的方法（）；
方法的重写（OverWrite）
也称为方法覆盖，是指子类对父类中已经存在的方法提供了一个新的实现。这意味着当你创建子类对象并调用一个重写的方法时，实际执行的是子类提供的版本，而不是父类的版本
要满足方法重写的要求，需要遵循以下规则：
1.方法名相同：子类和父类中的方法必须具有相同的名称
2.返回类型兼容：子类方法的返回类型必须与父类方法的返回类型相同或者为其子类型
3.参数列表相同：子类方法的参数列表（包括参数数量、类型和顺序）必须与父类方法完全相同
4.访问级别不能更严格：子类方法的访问级别不能低于父类方法的访问级别。例如，如果父类方法是public的，那么子类方法就不能是private或protected的
例：
/**所有一般学生类的定义*/
public class Student {
/**
* 所有学生都有学习的方法
*/
public void study(){
System.out.println("Student类中学习方法,学生名字是"+name);
}
private String name;
public void setName(String name) { //设定学生的名字
this.name = name;
}
public String getName(){
return name;
}
}重写
//继承Student类
public class UNStudent extends Student {
public void study(){ //重写了继承自父类中的方法
System.out.println("UNStudent学习,要独立,名字 "+getName());
}
}测试
//程序入口
public static void main(String[] args) {
UNStudent uns=new UNStudent(); //创建大学生类的对象
uns.setName("我是大学生"); //调用方法：这些方法是从父类中继承来的
uns.study();
}六、抽象类
被abstract修饰的类就是抽象类，抽象类不能被实例化
抽象方法：被abstract修饰的方法就是抽象方法，抽象方法没有方法体，只有方法的声明。当一个类包含至少一个抽象方法时，这个类必须声明为抽象类
子类继承抽象类的父类时，必须重写抽象类中的所有抽象方法
抽象类与抽象方法的定义
//抽象类的语法:
public abstract class 类名{
//属性定义
//普通方法定义
//抽象方法定义
......
}
//抽象方法的语法:
访问修饰符 abstract 返回值类型 方法名(参数列表);七、多态
多态就是一个对象可以以多种形式存在，即一个接口可以有多种实现方式，或者一个父类可以有多种子类
实现多态三个要求
1、要有继承
2、子类必须重写父类的方法
3、父类应用指向子类对象
向上转型与向下转型
1、向上：使用父类对象指向子类对象，实际上就是对象的向上转型。不需要进行强制类型转换
例：
Pet pet = new Dog();
Pet pet2 = new Cat();2、向下：使用父类的对象转换为子类对象，必须要进行强制的类型转换
例：
Pet pet = new Dog();
Dog d = (Dog)pet;instanceof关键字
它用于判断一个对象是否属于某个类或者其子类的实例
语法格式：
对象 instanceof 类(或接口)如果格式中的对象是类或接口的一个实例（包括类或接口的任何子类），那么instanceof运算符返回true；否则，它返回false
例：
public class TestInstanceof {
public static void main(String[] args) {
Pet p = new Dog(); //向上转型
if(p instanceof Dog){ //判断p是否是Dog类型
Dog d = (Dog)p; //如果是,我们就能转换
}else if(p instanceof Cat){
Cat c = (Cat)p; //向下转型
}
}
}接口
接口（Interface）是一种定义行为契约的方式。它是一个完全抽象的类型，只包含方法签名和常量的声明，而不包含任何实现。通过接口，可以强制一个类去遵循一套特定的方法规范，而具体实现这些方法的工作则交由实现该接口的类来完成。
接口的特征：
1、关键字：使用interface关键字来定义一个接口，接口中没有方法体，接口中没有构造方法，不能被实例化
2、方法：接口中的所有方法默认都是抽象的（public、abstract），因此不需要使用 abstract 关键字。从 Java 8 开始，接口还可以包含具有默认实现的静态方法以及提供具体实现的默认方法
3、变量：接口中的变量默认是静态的、最终的（static final），并且必须初始化。这意味着接口中的变量实际上是常量
4、接口的继承与多继承：接口可以继承其他接口，使用 extends 关键字，类似于类的继承。一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承
/**形状接口的定义:这个接口继承了另外两个接口*/
public interface NetJavaShape extends OtherShape,UsbInterface{
public final static String compName="华信";
//接口中定义的方法
void draw(int x1,int y1,int x2,int y2);
}5、接口的实现：类可以通过 implements 关键字来实现一个或多个接口，并且必须提供接口中所有抽象方法的具体实现
public class UDisk implements UsbInterface, Storable {
@Override
public void service() {
System.out.println("连接USB接口,开始传输数据");
}
}
扫一扫
317
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
