Java 【面向对象】

一.内存的分析

二.创建类和对象

//Person.java
public class Person{  //创建Person类
    String name;  //[属性]成员变量
    String gender;
    int age;
   
    /*无参数无返回*/
    public void eat(){ //方法
        System.out.println("我吃饭!");
    }

}

//demo.java
public class demo{
    public static void main(String[] args){
        Person My = new Person();              
        My.name = "你好!";  //设置属性值
        System.out.println(My.name); //输出
        My.eat();  //输出Person类的方法
    }
}

 上面的demo.java和Person.java在同一文件下,所以不需要import

三.面向对象和内存解析

 

四.有参数无返回值的调用

五.有参数有返回值的调用

//demo.java
public class demo{
    public static void main(String[] args){
        Person My = new Person();
        My.sleep("马路边");   //有参数无返回
        int age = My.getAge(12); //有参数有返回
        System.out.println("年龄是:"+age);
    }
}

//Person.java
public class Person{
    String name;  //[属性]成员变量
    String gender;
    int age;
   
    /*无参数无返回*/
    public void eat(){ //方法
        System.out.println("我吃饭!");
    }

    /*有参数,无返回*/
    public void sleep(String A){
       System.out.println("我在"+A+"睡觉");

    }

    /*有参有返回*/
    public int getAge(int a){
          
          return a;
    }

}

六.成员变量

//demo.java
public class demo{
     static int aa;  //成员变量
    public static void main(String[] args){
        Person one = new Person();
        System.out.println(one.name);
    }
}

//Person.java
public class Person{
    String name;  //[属性]成员变量
    String gender;
    int age;
   
    /*无参数无返回*/
    public void eat(){ //方法
        System.out.println("我吃饭!");
    }

    /*有参数,无返回*/
    public void sleep(String A){
       System.out.println("我在"+A+"睡觉");

    }

    /*有参有返回*/
    public int getAge(int a){
          
          return a;
    }

}

成员变量在未赋值的情况下,为null或者为0

七.return和多参方法

//Person.java
class Dog{  //定义类
    String name;
    public String print(String n,int a,char b){ //有参数有返回方法
         System.out.println(n);  //方法打印
         System.out.println(a);  //参数打印
         System.out.println(b);
         //return "fdfd"; //String 变量
         return "fdfd";
    }
    public void str(int a){ //有参数无返回方法
        if(a==0){  //a等于0
            System.out.println("你好");
        }else if(a==1){ //a等于1
            return;
        }
        System.out.println("我很好"); //
    }
}
public class Person{ //带有public名称和文件名相同
    public static void main(String[] args){
             Dog A = new Dog();
             String name = A.print("小明",12,'男');
             System.out.println(name);  //返回值输出
             A.str(0); //

    }
}

八.toString方法

//Person.java
class Cat{
    String name;
    int age;
    public String toString(){
           return "我的姓名:"+name+"我的年龄:"+age;
    }

}

public class Person{
    public static void main(String[] args){
        //String name = new String("你好");
        Cat one = new Cat();
        one.name = "小明";
        one.age = 12;
        System.out.println(one.toString());  //不是字符串转换为字符串
        System.out.println(one); 
    }
}

九.this关键字

十.理解封装的概念

/*封装
  1.就是把不想告诉别人的东西隐藏起来,把可以告诉别人的公开
  做法:修改属性的访问权限来限制对属性的访问。并为每一个属性创建一对取值方法和赋值方法
       用于对这些属性的访问。

*/
//demo.java
class Student{
     private String name;  //
     private int age;
     private char gender;//this.gender
     public void setGender(char gender){  //char gender为形参
         if(gender == '男'||gender == '女'){
         this.gender = gender;   //this.gender = 传入的gender
         }
         else{
             System.out.println("对不起,只能是[男]or[女]");
         }
     }
     public char getGender(){
         return this.gender;
     }
}

public class demo{
    public static void main(String[] args){
        Student one = new Student();
        one.setGender('人');
        System.out.println(one.getGender());
    }
}

十一.方法的重载

/* 方法的重载
方法的重载是指一个类中可以定义有相同的名字,但参数不同的多个方法
调用时会根据不同的参数列表选择对应的方法
*/
class Student{
    public void max(int a,int b){
         System.out.println(a>b?a:b);
    }
    public void max(double a,double b){
         System.out.println(a>b?a:b);
    }
    public void max(double a,double b,double c){
        double max = a>b?a:b;
        System.out.println(max>c?max:c);
    }
}
public class demo{
    public static void main(String[] args){
        Student one = new Student();
        one.max(3.4,6.7,6.9);
    }
}

十二.构造方法

//Person.java
/*构造方法
1.没有构造方法,Java会自动构造
Cat(){
    
}方法
2.构造函数与类同名,并且没有返回值
3.可以添加public


*/
class Cat{
    private String name;  //私有属性(变量)
    private int age;
    Cat(String name,int age){ //构造方法 (初始化方法),初始化方法不能加任何类型
        this.name = name;
        this.age = age;
        System.out.println("姓名:"+this.name+"年龄:"+this.age);
    }
    Cat(){ //方法重载

    }
    void get(){ //普通方法
        System.out.println("我是一个普通方法");
    }
}

public class Person{
    public static void main(String[] args){
        Cat one = new Cat("笑话",12);  //实例化
        one.get();  //调用普通方法
    }
}

十三.构造代码块

/*构造代码块
1.对象一建立就会运行,而且优先于构造函数执行
2.作用：给对象进行初始化
3.构造代码块和构造方法的区别:
   构造方法是对应的对象进行初始化
   构造代码块是给所有的对象进行同意的初始化

4.构造代码块是共性的初始化的内容
*/

public class example{
    public static void main(String[] args) {
        Person A = new Person();
        Person B = new Person("你好");
    }
}
//===类名
class Person{
    String name;
    Person(){
        System.out.println("我是无参数构造方法");
    }
    Person(String name){
        this.name = name;
        System.out.println("我是有参数构造方法");
    }
    {
        System.out.println("我是构造代码块");
    }
}

十四.构造方法之间的调用

public class example{
    public static void main(String[] args) {
    
        Person B = new Person("你好");
    }
}
//===类名
/*构造方法之间的调用
1.this：看上去,用来区分局部变量和成员变量同名的情况
2.this:就是代表本类对象,this代表它所在函数(方法)所属对象的应用
3.构造函数之间的调用只能通过this语句进行完成。
4.构造函数之间进行调用时this语句只能出现在第一行,初始化要先执行，如果初始化当中还有初始化
那就去执行更细致的初始化。

*/
class Person{
    String name;
    int age;
    Person(){
        System.out.println("无参数");
    }
    Person(String name){
        this();  //Person();
        this.name = name;
        System.out.println("我是名字1");
    }
    Person(String name,int age){
        this(name);// Person(name);
        this.age = age;
        
    }
    
}

十五.static的使用

Static 1 

 

/*Static静态变量
  每个对象都有共同的属性的时候,放到静态区域
  使用关键次static

 作用:是一个修饰符,用于修饰成员(成员变量，成员方法)
      1.可以重复使用,修饰后的成员变量只有一份
      2.当成员变量被static修饰后,多了一种访问方式,除了可以对象调用外
      还可以被类名直接调用(类名.静态成员)

 特点:1.随着类的加载而被加载 
      2.优先于对象的存在
      3.被所有的对象所共享的
      4.可以直接被类名所调用

*/
public class example{
    public static void main(String[] args) {
        System.out.println(Student.country); //（类名.静态成员）
        Student A = new Student();
        A.country = "中国";
        Student B = new Student();
        System.out.println(B.country);  //输出静态区域(对象.变量名)
    }
}

class Student{
    String name;
    int age;
    static String country;  //静态区域

}

/*Static静态变量
  每个对象都有共同的属性的时候,放到静态区域
  使用关键次static

 作用:是一个修饰符,用于修饰成员(成员变量，成员方法)
      1.可以重复使用,修饰后的成员变量只有一份
      2.当成员变量被static修饰后,多了一种访问方式,除了可以对象调用外
      还可以被类名直接调用(类名.静态成员)

 特点:1.随着类的加载而被加载 
      2.优先于对象的存在
      3.被所有的对象所共享的
      4.可以直接被类名所调用

 成员方法static修饰:
        生命周期:
        1.类的生命周期最长,随着类的消失而消失
        2.实例变量生命比类变量短

方法注意事项:
1.静态的方法只能访问静态的成员
2.非静态的方法既能访问静态的成员(成员变量、成员方法)也能访问非静态的成员
3.静态的方法中是不可以定义this super关键字
     因为静态优先于对象存在，所以静态方法不可以出现this

*/

public class example{
    public static void main(String[] args) {
        Student A = new Student();
        A.print();
    }
}

class Student{
    String name;  //成员变量
    int age;
    static String country;  //静态区域
    static void print(){  //静态方法和静态成员变量是同时产生,对象是之后出现
        String A = "你好";  //局部变量
        System.out.println(country);
    }
    void p(){
        System.out.println(country);
    }
}

十六.静态的使用范围

/*什么时候使用静态
static所修饰的内容是成员
1.从两方面入手
  1)什么时候使用静态的成员变量
     当属于同一个类的所有对象出现共享数据时
     需要将存储这个共享数据的成员变量用static修饰

  2)什么时候使用静态方法
    当功能内部不想访问到非静态的成员时(对象特有的数据)
    那么该功能可以定义成静态的。

*/
  public class example{
      public static void main(String[] args) {
          Person A = new Person(); //首先类出来,后对象实例化
          A.country = "China";
          A.print();
      }
  }

  class Person{
      String name;  //成员
      static String country;
     static void print(){
        System.out.println("你好" + country);
        //System.out.println(name);//静态方法不能访问非静态变量
    }

  }

十七.main方法

十八.练习-静态工具类

 

十九.总结学习方法

1.在学习的过程中,一定养成独立思考的能力
2.多练习,多敲代码，多做项目
3.在某些知识方面辅助是不扎实的表现,应当理解后自我完成
4.温故而知新
5.不懂的就要问,不能自己钻牛角