华清远见重庆中心-Java高级阶段总结/个人总结

Java面向对象

---

1.类

1.类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型

2.类是对象的模板，对象是类的一个个体，对应一个实例

3.一个Java类中只能有一个公开类，并且这个公开类的名字必须和.Java文件名相同

public class 类名{

成员变量；

成员方法；

}

2.对象

1.对象是具体的，实际的，代表一个具体事物, 即 是实例

2.创建对象 new 类名();

3.引用类型的变量，通过引用来操作对象。 类名 引用名 = new 类名()

代码实例

publicclassOop01{
    publicstaticvoidmain(String[] args) {
        //这个Point代表的是一 种数据类型 ，不代表一个具体点。
        // 我想表示X = 5， y=6的点， 这里就是-一个具体的点。
        //对象 new Point()，然后设置x=5，y=6.这一句创建的对象， 没有赋值给一个同类型的变量，         //导致无法找到这 个对象，然后修改了不了x, y的值。
        //Point p1这里的p1是- -个Point类 型的变量名。------- 引用
        //Point p1 = new Point() ;这里 表示把new来的Point对象，赋值给同类型的引用变量p1,           //然后通过p1操作对象的属性和方法。
        Pointpoint1=newPoint();//创建一个新的Point对象
        point1.x=5;//给新创建的对象赋值
        point1.y=6;//给新创建的对象赋值
        point1.up();//通过创建的对象调用类的成员方法,向上移动
        System.out.println("x:"+point1.x+" "+"y:"+point1.y);//输出当前对象的值
    }
}
classPoint {
    //类的特征（属性，成员变量）
    intx;//横坐标
    inty;//纵坐标
    publicvoidup(){
        //public:公开的方法
        //void:表示该方法无返回值
        //up() 无参函数
        y++;//向上移动1
    }

3.成员变量默认值

4.JVM内存结构

1.栈

1.用于存放程序运行过程中的局部变量

2.引用类型的变量p,是存储在栈内存中的

2.堆

1.jvm会在其内存空间开辟一个名为“堆”的存储空间，这部分空间用于存储使用new关键字创建的对象

2.创建了一个Person对象，存储在堆内存中

3.方法区

1.用于存放类的信息，程序运行首先会通过类加载器加载字节码文件，解析后将各种信息存放在该区域

5.方法重载

1.在Java语言中，允许多个方法名称相同，单参数列表不同，称之为方法的重载(overload).

2.程序在编译运行时，会根据参数列表和参数的数据类型不同去调用不同的方法

//jdk中的println()方法的重载

System.out.println(1);

System.out.println("sss");

System.out.println(shape);//shape引用指向对象的内存地址

System.out.println(newDate());//输出当前系统时间

注意：方法返回值类型与重载无关，只有参数个数或类型，以及方法名必须相同。

5.This关键字

1.在方法中可以通过关键字表示调用该方法的对象

2.通常在类中使用区分成员变量和参数

publicvoidup(inty){
    this.y=y;//通过this关键字来指代被操做的对象，然后访问到对象的成员变量
}

7.null

1.引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不知向任何对象

2.如果某个引用类型变量为null时，不能访问对象，否则抛空指针异常

3.如果引用为null就不能访问任何属性和方法

代码示例

8.构造函数

1.一般都是公开的，方便创建对象的时候调用

2.构造函数没有返回值，也不需要设置返回类型

3.构造函数的名字必须和类名相同

4.如果在类中没有定义无参构造函数，那么程序会自动添加无参构造函数

5。定义有参构造函数：创建对象时给成员变量赋值，使用有参构造函数

6.无参构造函数只调用一次

代码示例

publicclassCar {
    ints;
    //构造函数 
    publicCar(){
        System.out.println("调用了无参的构造函数");
    }
    //有参构造函数
    publicCar(ints){//使用无参构造函数给成员变量赋值
        this.s=s;
    }
    }

9.继承

1.extends关键字

1.子类继承父类，可以使用父类的成员

2.Java是单继承机制，一个类只能继承一个父类，但是父类可以继承其他类，子类也可以使用父类所继承类的成员

代码示例

publicclassAnimal {
    Stringcolor;//颜色
    Datebirth;//生日
    Stringsex;//性别
    intcount;//脚的数量
    publicvoideat(Stringfood){
        System.out.println("吃"+food);
    }
    publicvoidcry(Strings){
        System.out.println("叫---"+s);
    }
}
classChookextendsAnimal{//继承父类Animal
    //子类独有的方法fly()
    publicvoidfly(){
        System.out.println("小鸡在嘴里飞！！！");
    }
}

2.向上转型

1.子类对象赋值给父类的引用

2.向上转型后子类的特有成员则不能被使用

代码示例

Animaldog=newDog();//向上转型
dog.birth=newDate();
dog.color="黄色";
dog.sex="公狗";
dog.count=4;
//dog.seeDoor();这是属于Dog类特有的成员不能使用

3.向下转型

1.只能强转父类的引用，不能强转父类的对象

2.要求父类的引用必须指向的是当前目标类型的对象

3.当向下转型后，可以调用子类类型中的所有成员

Shapeshape=newShape();

Rectshape1=(Rect)shape;

4.instanceof关键字

1.对于一个父类的引用，可以指向父类的对象也可以指向其子类的对象

2.通过instanceof判断引用指向的对象的类型，可以强制转换成所需转向的实际类型

代码示例

Animaldog=newDog();
if(doginstanceofDog){
    Dogdog1=(Dog)dog;
}

5.继承中的构造方法

1.子类的构造方法中必须通过super调用父类的构造方法，是因为创建子类之前，必须先创建父类

2.子类的构造函数若没有直接使用super调用父类的构造方法，编译器会自动调用父类的无参构造方法

publicShape(){
    System.out.println("Shape无参构造函数被调用");
}
publicShape(intx,inty){
    this.x=x;
    this.y=y;
    System.out.println("shape有参构造函数被调用");
}

6.super关键字

1.调用父类的无参构造函数

2.如果要写super（）那么必须写在构造函数的第一行

publicRect(intx,inty){
    super(x,y);
    System.out.println("rect2个参构造函数被调用");
}

super 和 this的比较

7.方法重写(override)

1.子类继承父类的方法，若不能满足子类的需求，可以重写父类的方法，即方法名和参数列表类型与父类相同，方法内部功能不同

2.子类重写父类的方法后，子类对象优先调用子类的方法

3.子类可以在重写的方法中使用super调用父类的方法

​

public void area(){
    System.out.println("Shape area函数被调用");
}
class Rect extends Shape{
 public void area(){
       super.area()//调用的是父类的方法
        System.out.println("rect的area方法被调用了");
    }
}

1. • 重写与重载的区别

9.访问权限修饰符

10.return关键字

1. 用于对应函数中返回对应的数据

2. 如果在方法中使用则是结束代码，后面的代码不会执行

11.static关键字

1.有static修饰的成员就是静态成员

2.static修饰的成员变量不属于对象的数据结构，可以通过类名直接访问

3.static成员变量和类的信息都是存储在方法区的

4.一个类的静态成员变量只有一个，而非静态成员对象有多个

5.static修饰的方法不需要针对对象进行操作，也可以通过类名直接调用

6.static修饰的方法调用的时候没有具体的对象，因此static修饰的方法不能调用非静态成员

static修饰变量代码示例

classCat{
    intage;
    staticintnumber;
    publicCat(intage){
        this.age=age;
        number++;
}
    publicCat(Stringname,intage){
        this.name=name;
        this.age=age;
        sum++;//new一次就增加一只猫
    }
    publicvoidprint(){
        System.out.println("name:"+this.name+"  age:"+this.age+"  猫的数量："+sum);
    }
     publicstaticvoidmain(String[] args) {
        Catrose=newCat("Rose", 3);
        rose.print();//name:Rose  age:3  猫的数量：1
​
        Cat.sum=100;//静态成员变量修改之后其它成员调用时
         //值也会随着变化
        rose.print();//name:Rose  age:3 猫的数量：100
    }
}

​

static修饰方法代码示例

classCat{
    Stringname;
    intage;
    staticintnumber;
    publicCat(Stringname,intage){
        this.name=name;
        this.age=age;
        number++;
}
publicstaticvoidsay(){
    //System.out.println(this.name+this.age);静态方     //法不能使用非静态成员变量
    System.out.println(number);
}

12.final关键字

1.final修饰的类不能被继承

2.final修饰的方法不能被重写

3.final修饰的成员变量创建时必须赋值，该值不能被改变

代码示例

classB{
    finalvoidsay(){
        System.out.println("final方法");
    }
}
classCextendsB{
    finalstaticintSIZE=5;//可以通过类名调用该变量，并且值不能改变
    //void say();编译错误，父类中的say方法是final修饰的，不能被重写
    //SIZE=1000;编译错误，final定义的变量不能被重新赋值
    final  static  intMAX_AGE=120;
    final  static  intMIN_AGE=0;
}

13.对象数组

用对象数组保存对象的引用

Point[] points=newPoint[5];
for (inti=0; i<5; i++) {
    Pointpoint=newPoint(i, i+1);
    points[i] =point;
}

14.二维数组

1.先声明：类型 数组名;

2.再定义(开辟空间) 数组名 = new 类型大小

3.赋值(有默认值，比如 int 类型的就是 0)

15.抽象类--abstract

1.abstract关键字用于修饰方法或者类；

2.抽象方法

（1）、由abstract修饰的方法，只有方法定义，没有方法体

（2）、包含抽象方法的类必须是抽象类，不含抽象方法的类也可以是抽象类

3.抽象类

（1）、抽象类不能被实例化

（2）、抽象类需要被继承，不然没有意义

（3）、继承抽象类时，要么实现其抽象方法，要么将自己也定义为抽象类

代码示例

publicabstractclassShapes {//abstract表示是一个抽象类
    intx;
    inty;
    public  int  areas(){//当前方法没有实现计算面积的功能，
      return  0;
    }
    publicabstractintarea();//抽象方法没有主体，所有继承了该抽象类的子类必须实现类中的抽象方法
}
classCircleextendsShapes{
    intr;
     publicintarea() {
         returnr*r;
     }
 }

16.interface(接口)

1.接口用于制定规范

2.接口就是给出一些没有实现的方法，封装到一起，在被类继承后实现这些方法

3.接口是更加抽象的抽象类，接口中方法没有主体

interface 接口名{

属性；

抽象方法；

}

4.接口的继承，一个接口可以通过继承父接口拥有父接口的方法，且不用重写父类的方法

5.Java继承是单继承，但是一个类可以实现多个接口

6.接口的实现implements关键字

代码示例

publicinterfaceTigerextendsAnimal{
    //继承了父接口中的方法 eat等，可以不重写父接口中的方法
    publicabstractvoidmilk();
​
}
classEastTigerimplementsTiger{
​
    publicvoidmilk() {
        System.out.println("东北虎喝奶奶");
    }
 }

17.内部类

1.定义在类中的类，称为内部类

2.内部类的存在只服务于它所在的那个类，其内部方法体只供外部类服务，其他类无法使用

3.内部类的创建需要使用外部类对象的引用

代码示例

publicclassOuter {
    Stringname;
    intage;
    publicvoidout(){
        System.out.println("外部类的方法");
    }
    classInner{
        publicvoidprint(){
            System.out.println("内部类方法");
            System.out.println(name+"    "+age);
            out();//调用外部类方法
        }
    }
    publicstaticvoidmain(String[] args) {
        Outerouter=newOuter();
        outer.out();
        outer.name="r";
        outer.age=10;
        //new Inner()//编译错误 Inner是Outer的内部类，必须通过 外部类引用.new内部类   来创建对象
        Innerinner=outer.newInner();
        inner.print();
        System.out.println("-----------------");
        Innerinner1=newOuter().newInner();
        inner1.print();
    }

18.匿名内部类

如果在一段程序中需要创建一个类的对象（通常这个类需要实现接口或者继承某个类），而且创建后这个类就没用了，这个类不需要命名，就是匿名内部类

代码示例

publicclassTestInner1 {
    publicstaticvoidmain(String[] args) {
        Timertimer=newTimer();
​
        timer.schedule(newTimerTask() {//new  抽象类或者接口，然后在内部重写方法
            @Override
            publicvoidrun() {
                System.out.println("该起床了！！");
            }
        }, 1000, 1000);
​
    }
}

19.局部内部类

定义在类中方法中的类

publicclassTestInner03 {
    publicvoidfun(){
        classInner{
            publicvoidfun(){
                System.out.println("局部内部类的方法");
            }
        }
        Innerinner=newInner();
        inner.fun();
    }
​
    publicstaticvoidmain(String[] args) {
        TestInner03testInner03=newTestInner03();
        testInner03.fun();//fun被调用的时候局部内部类被创建
        //创建之后调用局部内部类的fun方法被调用
        
    }
}

20.抽象类和接口的区别

异：抽象类被继承之后，子类必须实现抽象类的方法接口被接口继承后不需要实现父接口的方法，且拥有父接口中的方法，抽象类中有构造方法，接口中没有抽象类中有非抽象方法，而接口中的方法都是公开的 抽象的方法抽象类中有成员变量，接口中只能定义常量使用public static final修饰子类通过extends继承抽象类，只能同时继承一个类子类通过implements实现接口，同时可以实现多个接口

21.值传递和引用传递

1.引用传递：

（1）如果一个方法的参数为引用类型，直接修改参数会改变引用的值

（2）若该方法中有创建了新的对象，那么参数修改不会对该引用造成改变

（3）若该方法中赋值了一个新字符串，那么传进来的引用也不会被改变

2.值传递：如果该方法传入参数为基本数据类型，那么该方法不会对实际参数造成影响

publicstaticvoidmain(String[] args) {
    Pointpoint=newPoint();
    point.setX(10);
    point.setY(5);
    point.print();//10,5
    TestPoint1(point);//将引用对象传入函数调用
    point.print();//10,5
    TestStr("Rone");//调用方法，传入引用参数
    intx=2;
    inty=3;
    testInt(x,y);//20,30 在函数体中被修改输出
    System.out.println("最后的x："+x+"最后的y："+y);//2,3 实际值没有变
}

22.==和equals的区别

1.==，用来判断基本数据类型时，是判断数据值是否相等

2.==，用来判断引用类型时，是判断引用指向的地址是否相等，即是否为同一个对象

3.equals是父类Object中提供的以一个方法，用来判断两个对象地址是否相等。

4.子类重写父类的equals方法，可以自己定义比较规则

23.代码块

1.静态代码块：类加载完成时只执行一次，该代码块是属于类的

2.普通代码块：创建一次对象就执行一次

类加载代码块执行顺序：静态代码块 普通代码块

个人阶段总结

---

在这一周的学习过程中，了解到了Java面向对象的一些知识，面向对象编程很好，大大提高了开发的效率，到后面的面向接口编程，也很不错，其思想就和面向对象非常类似，使得Java的开发变得更高效率，也很有利于程序的维护，这周还学习了很多关键字，每个知识中都有很多的细节需要记住，这些要在课后慢慢的去消化，还有平时的练习呢，我觉得可以适当多布置一点作业，让我们去巩固今天所学习的知识，还有自己的逻辑思维，以此来提升个人的编程能力，本周的学习个人感觉还很不错，希望后面可以更好。