面向对象.png

1.关键字：static

  1. package atguigu.java2;
  3. import java.util.jar.Attributes.Name;
  5. /*
  6.  *  static 关键字的使用
  7.  *
  8.  * 1.static：静态的  (或类变量)
  9.  * 2.static可以用来修饰：属性、方法、代码块、内部类
  10.  *
  11.  * 3.引用static修饰属性:静态变量
  12.  *    3.1属性，按是否使用static修饰，又分为：静态  vs 非静态属性（实例变量）
  13.  *      实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
  14.  *              非静态属性时，不会导致其他对象中同样的属性值的修改
  15.  *      静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
  16.  *              其他对象调用此静态变量时，是修改过了的。
  17.  *      3.2 static修饰属性的其他说明：
  18.  *         1.静态变量随着类的加载而加载.可以直接通过“类.静态变量”的方式进行调用
  19.  *         2.静态变量的加载要早于对象的创建 
  20.  *         3.由于类只会加载一次，则静态变量在内存中也只会存在一份
  21.  *         
  22.  *         4.     类变量         实例变量
  23.  *          类         yes           no
  24.  *          对象         yes          yes
  25.  *      
  26.  *      3.3 静态属性举例：System.out; Math.PI
  27.  *
  28.  *
  29.  *
  30.  *
  31.  * 4.引用static修饰方法:静态方法
  32.  *      1.随着类的加载而加载，可以通过“类.静态方法”的方式进行调用
  33.  *
  34.  *      2.     静态方法     非静态方法
  35.  *          类         yes     no
  36.  *          对象         yes     yes
  37.  * 
  38.  *         3. 静态方法中，只能调用静态的方法或属性
  39.  *           非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
  40.  * 
  41.  * 5.static注意点：
  42.  *    5.1在静态的方法内，不能使用this关键字、super关键字
  43.  *      5.2 关于静态属性和静态方法的使用，大家都从声明周期的角度去理解
  44.  *
  45.  * 6.开发中，如何确定一个属性是否要声明为static的？
  46.  *         > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的
  47.  * 
  48.  *   开发中，如何确定一个方法是否要声明为static的？
  49.  *        > 操作静态属性的方法，通常设置为static的
  50.  *        > 工具类中的方法，习惯上声明为static的。比如:Math,Arrays,Collections
  51.  */
  53. public class StaticTest {
  55.         public static void main(String[] args) {
  57.             Chinese.nation="中国";
  58.               System.out.println(Chinese.nation);
  59.             Chinese c1=new Chinese();
  60.             c1.name ="姚明";
  61.             c1.age=40;
  63.             Chinese c2=new Chinese();
  64.             c2.name ="马龙";
  65.             c2.age=30;
  67.             c1.nation ="CHN";
  68.             c2.nation ="CHINA";
  70.             System.out.println(c1.nation);
  71.             System.out.println(Chinese.nation);
  74.             c1.eat();
  75.             Chinese.show();
  76.             System.out.println(c1.name);
  78.         }
  80.     }
  81.     class Chinese{
  82.         String name;
  83.         int age;
  84.         static String nation;
  87.         public void eat(){
  88.             //在非静态方法中可以随意调用
  89.             System.out.println("中国人吃中餐");
  90.             name="Tom";
  92.             System.out.println(Chinese.nation);
  93.             walk();
  94.         }
  95.           //在静态方法中只能调用静态方法和属性
  96.         public static void show(){
  98.             //name="Tom";
  100.             System.out.println(Chinese.nation);
  101.             walk();
  103.         }
  105.         public static void walk() {
  107.         }
  109.     }

2.理解main方法的语法

  1. package shangguigu.java2;
  2. /*
  3.  *main()方法的使用说明：
  4.  * 1.main()方法作为程序的入口
  5.  * 2.main()方法也是一个普通的静态方法
  6.  * 3.mian()方法也可以作为我们与控制台交互的方式。(之前使用Scanner)
  7.  * 
  8.  * 
  9.  */
  10. public class MainTest {
  12.     public static void main(String[] args) {//入口
  14.         Main.main(new String[100]);
  16.         MainTest test =new MainTest();
  17.         test.show();
  19.     }
  20.     public void show() {
  22.     }
  23. }
  26. class Main{
  28.     public static void main(String[] args) {
  30.         for(int i=0;i<args.length;i++){
  31.             args[i]="args_ "+i;
  32.             System.out.println(args[i]);
  33.         }
  34.     }
  35. }
  39. package shangguigu.java2;
  41. import java.util.Scanner;
  43. public class MainDemo {
  45.     public static void main(String[] args) {
  47.         for(int i=0;i<args.length;i++){
  48.             System.out.println("********"+args[i]);
  50.             int num =Integer.parseInt(args[i]);
  51.             System.out.println("@@@@@@@"+num);
  53.         }
  55.     }
  58. }

3.类的成员之四：代码块

3.1代码块的使用

  1. package com.shangguigu.java;
  3. import org.omg.CORBA.PUBLIC_MEMBER;
  5. import atguigu.java2.StaticTest;
  7. /*
  8.  *类的成员之四：代码块（或初始化块） 
  9.  * 
  10.  * 1.代码块的作用：用来初始化类或对象
  11.  * 2.代码块如果有修饰的话，只能使用static
  12.  * 3.分类：静态代码块 vs 非静态代码块
  13.  * 
  14.  * 4.静态代码块
  15.  *      >内部可以有输出语句
  16.  *         >随着类的加载而执行，而且只执行一次
  17.  *         >作用：初始化类的信息
  18.  *         >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
  19.  *         >静态代码块的执行要优先于非静态代码块
  20.  *         >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
  21.  * 
  22.  * 5.非静态代码块
  23.  *         >内部可以有输出语句
  24.  *         >随着对象的创建而执行
  25.  *         >每创建一个对象，就执行一次
  26.  *         >作用：可以在创建对象时，对对象的属性等进行初始化
  27.  *         >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
  28.  *         >非静态代码块内可以调用静态的属性、静态的方法，或调用非静态的属性和方法
  29.  * 
  30.  * 
  31.  * 
  32.  */
  33. public class BlockTest {
  35.     public static void main(String[] args) {
  37.         String desc=Person.desc;
  38.         System.out.println(desc);
  39.         Person p1 =new Person();
  40.         Person p2 =new Person();
  41.         System.out.println(p1.age);
  44.         Person.info();
  45.     }
  47. }
  51. class Person{
  53.     //属性
  54.     String name;
  55.     int age;
  56.     static String desc="我是一个人";
  58.     //构造器
  59.     public Person(){
  61.     }
  63.     public Person(String name,int age){
  64.         this.name =name;
  65.         this.age=age;
  66.     }
  68.     //static代码块 跟随着类的加载就自己执行了
  69.     static{
  70.         System.out.println("hello，static block-1");
  71.         desc ="我是一个爱学习的人";
  72.     }
  74.     static{
  75.         System.out.println("hello，static block-2");
  77.     }
  79.     //非static代码块
  80.     {
  81.         System.out.println("hello，block-1");
  82.         age=1;
  83.     }
  86.     {
  87.         System.out.println("hello，block-2");
  88.         age=1;
  89.     }
  94.     //方法
  95.     public void eat(){
  96.         System.out.println("吃饭");
  97.     }
  99.     @Override
  100.     public String toString() {
  101.         return "Person [name=" + name + ", age=" + age + "]";
  102.     }
  104.     public static void info(){
  105.         System.out.println("我是一个快乐的人!");
  106.     }
  109. }

3.2属性赋值的执行先后顺序

  1. package com.shangguigu.java;
  2. /*
  3.  * 对属性可以赋值的位置：
  4.  * 1.默认初始化
  5.  * 2.显式初始化、5.在代码块中赋值
  6.  * 3.构造器中初始化
  7.  * 4.有了对象以后，可以通过“对象.属性” 或“对象.方法”的方式，进行赋值
  8.  * 
  9.  *  
  10.  * 执行的先后顺序：①--②/⑤--③---④
  11.  */
  12. public class OrderTest {
  14.     public static void main(String[] args) {
  15.         Order order =new Order();
  16.         System.out.println(order.orderId);
  17.     }
  19. }
  22. class Order{
  24.     int orderId=3;
  25.     {
  26.         orderId=4;
  27.     }
  29. }

4.关键字：final

  1. package com.shangguigu.java;
  2. /*
  3.  *final 最终的
  4.  *
  5.  * 1.final可以用来修饰的结构：类、方法、变量
  6.  * 
  7.  * 2.final 用来修饰一个类:此类不能被其他类所继承
  8.  *             比如：String类、System类、StringBuffer类
  9.  * 
  10.  * 3.final 用来修饰方法：表明方法不可以被重写
  11.  *             比如：object类的getClass();
  12.  * 
  13.  * 4.final 用来修饰变量:此时的“变量”就称为是一个常量
  14.  *         4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块的初始化、构造器的初始化
  15.  *         4.2 final修饰局部变量：
  16.  *              尤其是用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参，一旦赋值以后，就只能在方法体内
  17.  *             使用此形参，但不能重新赋值
  18.  * 
  19.  * static final 用来修饰属性：全局常量
  20.  * 
  21.  */
  23. public class FinalTest {
  25.     //The final field FinalTest.width cannot be assigned
  26.     final int width = 10;//显示赋值
  29.     final int left;
  30.     final int right;
  33.     //代码块的初始化
  34.     {
  35.         left=1;
  36.     }
  38.     //构造器的初始化
  39.     public FinalTest(){
  41.         right =2;
  42.     }
  45.     //不可以使用对象.方法来进行调用
  46. //    public void setDown (int down){
  47. //        this.Down=down;
  48. //    }
  51.     public void doWidth(){
  53.         //width=20;
  54.     }
  57.     public void show(){
  59.         final int NUM=10;
  61.         //The final local variable NUM cannot be assigned. It must be blank and not using a compound assignment
  62.         //NUM+=20;
  63.     }
  65.     //将形参定义成final是可以进行输出的调用的，但是不可以进行再修改
  66.     public void show(final int num){
  68.         //num=200;  //The final local variable num cannot be assigned.
  69.         System.out.println(num);
  70.     }
  75.     public static void main(String[] args) {
  76.         int num=10;
  78.         num= num + 5;
  79.     }
  86. }
  90. final class FinalA{
  92. }
  94. //
  95. //class B extends FinalA{
  96. //    
  97. //}
  99. //String类不能被继承
  100. //class c extends String{
  101. //    
  102. //}
  105. class AA{
  106.     public final void show(){
  108.     }
  109. }
  112. class BB extends AA{
  114.     //show继承与final类不能被重写
  115. //    public void show(){
  116. //        
  117. //    }
  118. }

5.抽象类与抽象方法

5.1abstract关键字的使用

  1. package com.shangguigu.java;
  2. /*
  3.  * abstract关键字的使用
  4.  * 1.abstract：抽象的
  5.  * 2.abstract可以用来修饰的结构:类、方法
  6.  * 
  7.  * 3.abstract修饰类：抽象类
  8.  *         >此类不能实例化
  9.  *         >抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
  10.  *         >开发中，都会提供抽象类的子类，让子类对象进行实例化，完成相关的操作
  11.  * 
  12.  * 4.abstract修饰方法：抽象方法
  13.  *         >抽象方法只有方法的声明，没有方法体
  14.  *         >包含抽象方法的类，一定是抽象类。反之，抽象类中是可以没有抽象方法的
  15.  *         >若子类重写了父类中所有的抽象方法后，此子类方可实例化
  16.  *        >若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract来进行修饰
  17.  *
  18.  *
  19.  *
  20.  *
  21.  */
  23. public class AbstractTest {
  25.     public static void main(String[] args) {
  27.         //Cannot instantiate the type Person
  28.         //一旦Person类抽象了，就不可以实例化了
  29. //        Person p1=new Person();
  30. //        p1.eat();
  32.     }
  33. }
  36. abstract class Creature{
  37.     public abstract void breath();
  39. }
  45. abstract class Person extends Creature{
  46.     String name;
  47.     int age;
  49.     public Person(){
  51.     }
  53.     public Person(String name,int age){
  54.         this.name=name;
  55.         this.age=age;
  57.     }
  60.     //不是抽象方法
  61. //     public void eat(){
  62. //        
  63. //    }
  65.     //抽象方法
  66.     public abstract void eat();
  71.     public void walk(){
  72.         System.out.println("人走路");
  73.     }
  75. }
  77.  class Student extends Person{
  79.     public Student(String name,int age){
  81.         super(name,age);
  82.     }
  84.     public void eat(){
  85.         System.out.println("孩子应该多吃有点营养的食物");
  86.     }
  88.     @Override
  89.     public void breath() {
  90.         System.out.println("学生应该要呼吸新鲜的空气");
  92.     }
  98. }

5.2abstract使用上的注意点

  1. package com.shangguigu.java;
  2. /*
  3.  * abstract使用上的注意点：
  4.  *  1.abstract不能用来修饰：属性、构造器等结构
  5.  *  
  6.  *  2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类
  7.  * 
  8.  * 
  9.  * 
  10.  * 
  11.  */
  12. public class AbatractTest1 {
  14. }

6.接口（interface）

6.1接口的定义

  1. package com.shangguigu.java3;
  2. /*
  3.  *接口的使用
  4.  *1.接口使用interface来定义 
  5.  *2.Java中，接口和类是并列的两个结构
  6.  *3.如何定义接口，定义接口中的成员
  7.  *      
  8.  *        3.1 JDK7及以前：只能定义全局常量和抽象方法
  9.  *            >全局常量：public static final的，但是书写的时候，可以省略不写
  10.  *            >抽象方法：public abstract的
  11.  *
  12.  *            
  13.  *         3.2 JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)
  14.  * 
  15.  * 4.接口中不能定义构造器的！意味着接口不可以实例化
  16.  * 
  17.  * 5.Java开发中，接口都通过让类去实现(implements)来使用
  18.  *   如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
  19.  *   如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍然是一个抽象类
  20.  *   
  21.  * 6.Java类可以实现多个接口  ---> 弥补了java单继承性的局限性问题
  22.  *         格式：class AA extends BB implement CC,DD,EE
  23.  * 
  24.  * 7.接口与接口之间可以继承，而且可以多继承
  25.  * 
  26.  * *******************************************************************
  27.  * 8.接口的具体使用，体现多态性
  28.  * 9.接口，实际上就可以看做是一种规范
  29.  * 
  30.  * 
  31.  * 
  32.  */
  33. public class InterfaceTest {
  35.     public static void main(String[] args) {
  37.         System.out.println(Flyable.MAX_SPEED);
  38.         System.out.println(Flyable.MIN_SPEED);
  41.         Plane p1=new Plane();
  42.         p1.fly();
  44.     }
  47. }
  49. interface Flyable{
  51.     //全局常量
  52.     public static final int MAX_SPEED =7900; //第一宇宙速度
  53.     int MIN_SPEED =1;//省略了public static final
  56.     //抽象方法
  57.     public abstract void fly();
  59.     void stop();//省略了 public abstract
  63.     //Interfaces cannot have constructors 
  64.     //public Flyable(){}
  70. }
  73. interface Attackable{
  75.     Void attack();
  77. }
  83.  class Plane implements Flyable{
  86.      //implements com.shangguigu.java3.Flyable.fly
  87.     @Override
  88.     public void fly() {
  89.         System.out.println("通过引擎起飞");
  91.     }
  93.     @Override
  94.     public void stop() {
  95.         System.out.println("驾驶员减速停止");
  97.     }
  99. }
  101.  //因为没有重写所有的方法，所以仍旧是一个抽象类
  102.  abstract class kite implements Flyable{
  104.     @Override
  105.     public void fly() {
  108.     }
  111.  }
  114.  //Bullet类可以实现等多个接口,要继承接口CC,那同时就需要满足AA和BB的父接口的方法
  115.  class Bullet extends Object implements Flyable,Attackable,CC{
  117.     @Override
  118.     public Void attack() {
  119.         // TODO Auto-generated method stub
  120.         return null;
  121.     }
  123.     @Override
  124.     public void fly() {
  125.         // TODO Auto-generated method stub
  127.     }
  129.     @Override
  130.     public void stop() {
  131.         // TODO Auto-generated method stub
  133.     }
  135.     @Override
  136.     public void method() {
  137.         // TODO Auto-generated method stub
  139.     }
  141.     @Override
  142.     public void method2() {
  143.         // TODO Auto-generated method stub
  145.     }
  147.  }
  149.  //*************************************************
  151.  interface AA{
  152.      void method ();
  153.  }
  155.  interface BB{
  156.      void method2 ();
  157.  }
  159.  interface CC extends AA,BB{
  161.  }

6.2接口的使用方法

  1. package com.shangguigu.java3;
  2. /*
  3.  * 接口的使用
  4.  * 1.接口的使用上也满足多态性
  5.  * 2.接口实际上是定义了一种规范
  6.  * 3.开发中，体会面向接口编程
  7.  * 
  8.  * 
  9.  * 
  10.  * 
  11.  * 
  12.  */
  13. public class USBTest {
  14.     public static void main(String[] args) {
  15.         Computer com =new Computer();
  17.         //1.创建了接口的非匿名实现类的非匿名对象
  18.         Flash flash =new Flash();
  19.         com.transferData(flash);
  21.         //2.创建了接口的非匿名实现类的匿名对象
  22.         com.transferData(new Printer());
  24.         //3.创建了接口的匿名实现类的非匿名对象
  25.         USB phone =new USB(){
  27.             @Override
  28.             public void start() {
  29.                 System.out.println("手机开始工作");
  31.             }
  33.             @Override
  34.             public void stop() {
  35.                 System.out.println("手机结束工作");
  37.             }
  40.         };
  41.         com.transferData(phone);
  43.         //4.创建了接口的匿名实现类的匿名对象
  44.         com.transferData(new USB() {
  46.             @Override
  47.             public void stop() {
  48.                 System.out.println("MP3开始工作");
  50.             }
  52.             @Override
  53.             public void start() {
  54.                 System.out.println("MP3结束工作");
  56.             }
  57.         });
  61.     }
  62. }
  66. class Computer{
  68.     public void transferData(USB usb){
  69.         usb.start();
  71.         System.out.println("具体的传输数据的细节");
  73.         usb.stop();
  76.     }
  78. }
  83. interface USB{
  84.     //定义了长、宽、最大最小的传输速度等
  86.     void start();
  88.     void stop();
  90. }
  92. class Flash implements USB{
  94.     @Override
  95.     public void start() {
  96.         System.out.println("U盘开始工作");
  98.     }
  100.     @Override
  101.     public void stop() {
  102.         System.out.println("U盘结束工作");
  104.     }
  106. }
  109. class Printer implements USB{
  111.     @Override
  112.     public void start() {
  113.         System.out.println("打印机开始工作");
  115.     }
  117.     @Override
  118.     public void stop() {
  119.         System.out.println("打印机结束工作");
  121.     }
  123. }

7.类的成员之五：内部类

  1. package com.atguigu.java3;
  2. /*
  3.  * 
  4.  * 类的内部成员之五：内部类
  5.  * 1.Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B就是外部类
  6.  * 
  7.  * 2.内部类的分类：成员内部类 (静态的和非静态的)vs 局部内部类（方法内、代码块内、构造器内）
  8.  * 
  9.  * 3.成员内部类：
  10.  *         一方面，作为外部类的成员：
  11.  *             >调用外部类的结构
  12.  *             >可以被static修饰
  13.  *             >可以被4种不同的权限修饰
  14.  * 
  15.  *         另一方面，作为一个类：
  16.  *             >类内可以定义属性、方法、构造器等
  17.  *             >可以用final去修饰，表示此类不能被继承。言外之意，如果不使用final，是可以被继承的
  18.  *             >可以被abstract修饰
  19.  * 
  20.  *
  21.  * 4.关注如下3个问题
  22.  *         4.1 如何实例化成员内部类的对象
  23.  *         4.2 如何在成员内部类中区分调用外部类的结构
  24.  *         4.3 开发中局部内部类的使用
  25.  */
  26. public class InnerClassTest {
  28.     public static void main(String[] args) {
  30.         //创建Dog实例（静态的成员内部类）:
  31.         Person.Dog dog=new Person.Dog();
  32.         dog.show();
  34.         //创建一个Bird实例（非静态的成员内部类）
  35. //        Person.Bird bd=new Person.Bird(); 错误的
  36.         Person p =new Person();
  37.         Person.Bird bird= p.new Bird();
  38.         bird.sing();
  41.         System.out.println();
  43.         bird.display("黄鹂");
  46.     }
  48. }
  50. class Person{
  52.     String name="杜鹃";
  53.     int age;
  54.     public void eat(){
  55.         System.out.println("人吃饭");
  56.     }
  60.     //静态成员内部类
  61.      static class Dog{
  62.         String name="小明";
  63.         int age;
  65.         public void show(){
  66.             System.out.println("卡拉是条狗");
  67. //            eat();
  68.         }
  70.     }
  71.     //非静态成员内部类
  72.     class Bird{
  73.         String name="小明";
  75.         public Bird(){
  77.         }
  79.         public void sing(){
  80.             System.out.println("我是一只小小小鸟");
  81.             Person.this.eat();//调用外部类的属性
  82.         }
  86.         public void display(String name){
  87.             System.out.println("**************************");
  88.             System.out.println(name);//方法的形参
  89.             System.out.println(this.name);//内部类的属性
  90.             System.out.println(Person.this.name);//外部类的属性
  91.         }
  94.     }
  98.     public void method(){
  99.         //局部内部类
  100.         class AA{
  102.         }
  104.         //局部内部类
  105.         class BB{
  107.         }
  109.     }
  111.     public Person(){
  113.         class CC{
  115.         }
  116.     }
  119. }

image.png