手捏Java知识点

客官°小女子只卖身不卖艺 2023-10-13 16:17 13阅读 0赞

### 今天开始面向对象了 ###

![在这里插入图片描述][db59a8bca79946829036bc0a0e19dd6c.png]

#### 面向对象基础 ####

类：由属性和行为组成
            属性：在类中通过成员变量来体现
            行为：在类中通过成员方法来体现
            public class 类名{
                //成员变量
                变量1的数据类型 变量1;
                变量2的数据类型 变量2;
                ...
                //成员方法
                方法1;
                方法2;
                ...
            }

##### 有几个重要的概念和特性需要了解。 #####

![在这里插入图片描述][ef424483a42846ffab3555ee71de3ea1.png]

###### 类和对象 ######

在Java中，类是描述具有相同属性和行为的对象的蓝图。通过定义类，可以创建
    多个实例，即对象。对象是类的具体实现，并且可以使用其属性和方法来完成特
    定的任务。

###### 封装 ######

封装是将数据和操作组合起来，以便通过类的接口访问它们。通过将数据字段隐
    藏在类的内部，并提供公共方法来访问和修改数据，可以保护数据的完整性和安
    全性。

![在这里插入图片描述][58bf928653ff4a96824bf070957d39e0.png]

###### 继承 ######

继承是指一个类获得另一个类的属性和方法。通过继承，子类可以重用父类的代
    码，并且还可以添加自己的特定功能。在Java中，使用关键字extends实现继承
    关系。

###### 多态 ######

多态是指一个对象可以表现出多种形态或类型。通过多态，可以使用统一的接
    口来处理不同类型的对象，提高代码的可复用性和可拓展性。在Java中，多态
    可以通过方法的重写和接口的实现来实现。

###### 抽象类与接口 ######

抽象类是无法被实例化的类，它可以包含抽象方法和非抽象方法。抽象方法只有
    声明而没有具体实现，需要子类去实现。接口定义了一组方法的规范，任何类都
    可以实现一个或多个接口。不同类之间通过继承抽象类或实现接口来共享代码
    和行为。

![在这里插入图片描述][68f2b1effdad4c4898524d364a8d6370.png]

除此之外还有其他一些与面向对象相关的概念，如构造函数、方法重载、访问修饰符等。理解这些基础知识也很重要。

##### 代码示例 #####

`定义一个新的手机类并在这个类中使用`。

public class crj {
        
        public static void main(String[] args) {
        
            Phone p = new Phone();
            //使用成员变量
            System.out.println(p.brand);
            System.out.println(p.price);
    
            p.brand = "小米";
            p.price = 2999;
    
            System.out.println(p.brand);
            System.out.println(p.price);
    
            //使用成员方法
            p.call();
            p.sendPassage();
        }
    }

`新定义一个学生类，并在这个类中使用`。

public class crj {
        
       public static void main(String[] args) {
        
           Student s = new Student();
           //调用成员变量
           s.name="高启强";
           s.age=39;
           System.out.println(s.name+s.age);
           //调用成员方法
           s.study();
           s.doHomework();
       }
    }
    public class Student {
        
       //成员变量
       String name;
       int age;
       //private int age;
    
       public void setAge(int a) {
        
    //        age = a;
           if (a < 0 || a > 120) {
        
               System.out.println("年龄有误");
           } else {
        
               age = a;
           }
       }
    
       //成员方法
       public void study() {
        
           System.out.println("好好学习");
       }
    
       public void doHomework() {
        
           System.out.println("多加练习");
           int j = 0;
       }
    
       public void show() {
        
           System.out.println(name + "," + age);
       }
       public String getName(){
        
           return name;
       }
       public int getAge(){
        
           return age;
       }
    }

![在这里插入图片描述][1a721620577743d1b1cf758cbd21f185.png]

#### private关键字 ####

是一个权限修饰符
        可以修饰成员
        作用：保护成员不被别的类使用，
                被private修饰的成员只在本类中才能访问
        使用方法
            提供get变量名()用于获取成员变量的值，方法用public修饰
               set变量名(参数)用于设置成员变量的值方法用public修饰
    
    
    	在Java中，private是一种访问修饰符（access modifier），用于控制类
    	的成员（字段和方法）的可见性。具体来说，private修饰的成员只能在所
    	属类的内部访问，而在类的外部是不可见的。
    
    	使用private关键字可以实现封装（encapsulation）的概念，将类的内部
    	数据和实现细节隐藏起来，只暴露必要的接口给外部使用。这样做的好处是
    	可以提高代码的安全性和可维护性，防止外部代码直接访问类的私有成员，
    	从而避免不经意间改变了类的内部状态。

`下面演示了private关键字的使用：`

public class Person {
        
       private String name;
       private int age;
       
       public Person(String name, int age) {
        
           this.name = name;
           this.age = age;
       }
       
       public void sayHello() {
        
           System.out.println("Hello, my name is " + name);
       }
       
       private void increaseAge() {
        
           age++;
       }
       
       public void celebrateBirthday() {
        
           increaseAge();
           System.out.println("Happy birthday! Now I'm " + age + " years old.");
       }
    }

在上述代码中，name和age字段被声明为private，只能在Person类的内部访
    问。sayHello方法是公有方法，可以被外部代码调用。increaseAge方法被声明
    为private，只能在Person类的内部调用。
    这意味着，当我们创建一个Person对象并调用celebrateBirthday方法时，
    age的增加是在类的内部发生的，外部代码无法直接访问和更改age的值。

Person person = new Person("Alice", 25);
    person.sayHello();  // 正确，输出：Hello, my name is Alice
    person.increaseAge();  // 错误，无法调用私有方法
    System.out.println(person.age);  // 错误，无法访问私有字段
    person.celebrateBirthday();  // 正确，输出：Happy birthday! Now I'm 26 years old.

##### 总之 #####

private关键字用于限制类的成员的访问范围，只允许在所属类的内部访问。通
    过使用private关键字，可以实现封装，提高代码的安全性和可维护性。

![在这里插入图片描述][8dd122f9a4e240c49af90bdee2ec9b08.png]

#### this关键字 ####

##### 主要有以下几个用途： #####

###### 引用当前对象的实例变量 ######

在类的方法内部，如果局部变量和实例变量同名，可以使用this关键字来指定访
    问实例变量。例如：this.variableName。

###### 调用当前对象的其他方法 ######

在类的某个方法内部，可以使用this关键字来调用当前对象的其他方法。
    例如：this.methodName()。

###### 在构造方法中调用其他构造方法 ######

在一个类中，可以定义多个构造方法，通过使用不同的参数列表进行重载。如果
    一个构造方法需要调用另一个构造方法，可以使用this关键字。
    例如：this(parameters)。

##### 代码示例 #####

public class crj {
        
        public static void main(String[] args) {
        
            Student2 s = new Student2();
    
            s.setName("林清玄");
            s.setAge(30);
            System.out.println(s.getName()+","+s.getAge());
        }
    }
    public class Student2 {
        
        private String name;
        private int age;
    
        public void setName(String name) {
        
            this.name = name;
        }
        public String getName(){
        
            return name;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
        public int getAge(){
        
            return age;
        }
    }

![在这里插入图片描述][88319a016f434556b9d54f8ed85b627f.png]

#### 构造方法注意事项 ####

创建 如果没有定义，系统将给出一个默认的无参构造方法
              如果定义了，系统将不再提供默认构造方法
        重载 如果自定义了带参构造方法，还想使用无参构造方法，就必须再写
        		一个无参构造方法
        推荐 永远提供无参构造方法
    
    	构造方法名称必须与类名完全相同，大小写也要匹配。
    
    	构造方法没有返回类型，连 void 关键字也不需要。
    
    	如果没有显式地定义构造方法，Java 会自动为类定义一个默认的无参构
    	造方法。
    
    	如果自定义了有参数的构造方法，Java将不会自动创建无参构造方法。这
    	就意味着，如果需要创建一个对象，必须显式地提供一个无参构造方法。
    
    	如果类中同时存在无参构造方法和有参构造方法，那么在创建对象时默认
    	首选无参构造方法。
    
    	构造方法可以重载，也就是说可以定义多个具有不同参数列表的构造方法，
    	以应对不同的对象创建需求。
    
    	在子类中，构造方法的第一行必须是调用父类的构造方法，否则编译器会自
    	动添加默认的 super() 方法调用。

[db59a8bca79946829036bc0a0e19dd6c.png]: https://img-blog.csdnimg.cn/db59a8bca79946829036bc0a0e19dd6c.png
[ef424483a42846ffab3555ee71de3ea1.png]: https://img-blog.csdnimg.cn/ef424483a42846ffab3555ee71de3ea1.png
[58bf928653ff4a96824bf070957d39e0.png]: https://img-blog.csdnimg.cn/58bf928653ff4a96824bf070957d39e0.png
[68f2b1effdad4c4898524d364a8d6370.png]: https://img-blog.csdnimg.cn/68f2b1effdad4c4898524d364a8d6370.png
[1a721620577743d1b1cf758cbd21f185.png]: https://img-blog.csdnimg.cn/1a721620577743d1b1cf758cbd21f185.png
[8dd122f9a4e240c49af90bdee2ec9b08.png]: https://img-blog.csdnimg.cn/8dd122f9a4e240c49af90bdee2ec9b08.png
[88319a016f434556b9d54f8ed85b627f.png]: https://img-blog.csdnimg.cn/88319a016f434556b9d54f8ed85b627f.png