java中级总结

1.类与对象

• 类：类是一个模板，它描述一类对象的行为和状态。

• 对象：对象是类的一个实例，有状态和行为。

  类包括有：
  1.局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
  2.成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
  3.类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

• 构造方法：每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认的无参构造方法。

2.this与static

• this：this 是自身的一个对象，代表对象本身。用法为：

     1.普通的直接引用
     2.形参与成员名字重名，用 this 来区分

//声明一个自定义对象
public class emp {
    private String name;
    public emp(String name) {
      //this 同名时，用来区别方法形参与成员变量
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
      //this 同名时，用来区别方法形参与成员变量
        this.name = name;
    }
}
//测试类
public class test {
    public void t1（）{
        emp emp = new emp("gui");
        System.out.println(emp.getName());
    }
}
//运行结果
   gui

• static：在类中，用static声明的成员变量为静态成员变量，也成为类变量，方法称为静态方法，代码快称为静态代码块类变量的生命周期和类相同，在整个应用程序执行期间都有效
• 静态方法与非静态方法区别
  1.静态变量被所有对象共享，在内存中只有一个副本，在类初次加载的时候才会初始化
  2.非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响
• static修饰的方法的调用： 类名.方法();

3.面向对象三个特性

3.1封装

• 封装：将抽象性函式接口的实现细节部分包装、隐藏起来的
• 封装的优点： 1. 封装能够减少耦合
                         2.类内部的结构可以自由修改。
                         3.可以对成员变量进行更精确的控制。

/**封装自定义对象*/
public class Person{
  //将属性的访问修饰符改为私有
   private String name;
   private int age;
​  //添加对外界访问的方法
   public int getAge(){
     return age;
   }
   public String getName(){
     return name;
   }
   public void setAge(int age){
     this.age = age;
   }
   public void setName(String name){
     this.name = name;
   }}
   /**测试自定义对象*/
    public class Test {
    @Test
     public void t1(){
     Person  person = new  Person();
     person.setName("gui");
     person.setAge(20);
     System.out.print("Name:"+person.getName()+"，  Age : "+person.getAge());
   }
   }
   /**运行结果*/
   Name:gui，Age:20

3.2继承

• 继承：子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
• 继承的特点：1.子类拥有父类非 private 的属性、方法。
                         2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
                         3.子类可以用自己的方式实现父类的方法(方法重写)
• 继承关键字：extends，implements，因为Java继承是单继承，使用implements关键字可以变相的达到多继承效果

/**父类user*/
public class user {
    private String name;
    private int age;
    public user() {
    }
    public user(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println(name+"正在吃");
    }
}
/**接口emp*/
public interface emp {
    public void sleep(String name);
}
/**user02继承user类并且引用emp接口*/
public class user02 extends  user implements emp {
    public user02(String name, int age) {
        super(name, age);
    }
    @Override
    public void sleep(String name) {
        System.out.println(name+"在睡觉");
    }
}
/**测试类*/
 public class Test {
   @Test
    public void test02(){
        user02 user =new user02("gui",20);
        user.eat();
        user.sleep(user.getName());
    }
 }
 /**运行结果*/
 gui正在吃
 gui在睡觉

3.3多态

• 多态就是同一个接口，使用不同的实例而执行不同操作，当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

/**父类*/
public abstract class Animal {  
    abstract void eat();  
}  
/**子类*/ 
public class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
 /**子类*/ 
public class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}
/**测试代码*/ 
 public class Test {
   @Test
    public void test01(){
     Animal a = new Cat(); 
      a.eat();               
      Cat c = (Cat)a;       
      c.work();        /
  }  
  /**运行结果*/ 
    吃鱼
    抓老鼠

4.内部类

• 内部类大致分为四种

内部类名称	说明
成员内部类	最普通的内部类，即在类中在定义一个类
局部内部类	即定义在一个类的方法或者一个作用域里面的类
匿名内部类	即不定义名字的内部类
静态内部类	修饰符为static的成员内部类

成员内部类：成员内部类访问外部类时可以无条件访问外部类的所有成员属性和成员方法，外部类访问访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问;

//内部类访问外部类演示
public class user {
    public static age=10
    class emp {     //内部类
        public void getage() {
          //打印结果为10，可以直接调用
            System.out.println(age);
        }}}

        //外部类访问内部类演示
    public class user {
      //使用emp里面的内容时调用t1()方法
    public emp t1(){
    return new emp;
   }
    class emp {     //内部类
        public void haha() {
            System.out.println("哈哈");
        }}}

局部内部类：局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。