1.1面向过程与面向对象的区别
1.编程思想不同
面向过程:是一种以过程为中心的编程思想。都是以什么正在发生为主要目标进行编程。
面向对象:是一类以对象作为基本程序结构单位的程序设计语言,指用于描述的设计是以对象为核心,而对象是程序运行时刻的基本成分。
2.特点不同
面向过程:就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。
面向对象:是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。
3.优势不同
面向过程:不支持丰富的“面向对象”特性(比如继承、多态),并且不允许混合持久化状态和域逻辑。
面向对象:在内部被表示为一个指向一组属性的指针。任何对这个对象的操作都会经过这个指针操作对象的属性和方法。
1.2面向对象三大特性
继承:
封装:
多态:
1.3类与对象的概念
什么是对象?
万物皆对象。它包括现实中客观存在的事物,也包括抽象的时间、规则、思维。简单点说,对象具有状态、行为和标识。
什么是类?
具有相同特性和行为的对象组成的集合就是类,JAVA实际中的类就是指一个数据类型。
类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。类的实例化结果就是对象,而对一类对象的抽象就是类,类描述了一组有相同属性和相同方法的对象。
如:
public class Student{ int num; String name; int age; }
1.5对象的创建和使用
Student stu = new Student();
stu.name = ”张三“; //对成员变量进行赋值
1.6面向对象的封装性
public class Student{ private int num; private String name; private int age; }
而此时访问属性,需要使用get,set方法:
class Student{ private int num; private String name; private int age; //get方法 public int getNum() { return num; } //set方法 public void setNum(int num) { this.num = num; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
在main函数中调用get,set方法:
public class Test { public static void main(String[] args) { Student stu = new Student(); stu.setAge(22); System.out.println(stu.getAge()); } }
得到年龄属性值为22
1.7构造函数,构造方法,构造器
构造方法特点:
构造方法名与类名一致
没有返回值,也不能有void关键字
任何类都有构造方法,如果没有显式定义出来,系统会为该类定义一个默认构造器(无参构造方法)
代码:
class Student{ int num; String name; int age; //无参构造器 public Student(){ } //有参构造器 public Student(int num, String name, int age) { this.num = num; this.name = name; this.age = age; } }
public class Test13 { public static void main(String[] args) { Student stu = new Student(181,"张三",22); } }
1.8对象和引用
1.8.1Java 内存的主要划分
1.8.2Test.java内存表示
第一步,执行 main 方法,将 main 方法压入栈,然后 new Student 对象
1.9this关键字
class Student{ int num; String name; int age; public Student(int num, String name, int age) { this.num = num; this.name = name; this.age = age; } }
//调用另一个构造方法
public class Test13 {
public static void main(String[] args) {
Student stu = new Student(182,"李四");
System.out.println(stu.num + " " +stu.name + " " +stu.age);
}
}
class Student{
int num;
String name;
int age;
public Student(int num,String name){
this(181,"张三",22);
}
public Student(int num, String name, int age) {
this.num = num;
this.name = name;
this.age = age;
}
}
class Animal{ public void move(){ System.out.println("Animal is"); } } class Bird extends Animal{ public void fly(){ System.out.println("Bird is"); } }
1.12方法的覆盖 override
又被称为方法重写
什么时候使用方法重写:
父类中的方法已经无法满足当前子类的业务需求,子类有必要将父类中继承过来的方法进行重写
建议方法重写的时候尽量进行复制粘贴
方法重写发生在具有继承关系的父子类之间
方法重写的时候,返回值类型相同,方法名相同,参数列表相同
覆盖只针对方法,不谈属性
public class Test05 { public static void main(String[] args) { Animal a = new Animal(); a.move(); Bird b = new Bird(); b.move(); } } class Animal{ public void move(){ System.out.println("Animal is"); } } class Bird extends Animal{ public void fly(){ System.out.println("Bird is"); } @Override public void move() { //super.move(); System.out.println("覆盖父类中的方法"); } }
public class Test05 { public static void main(String[] args) { Animal a = new Animal(); a.move(); Bird b = new Bird(); b.move(); } } class Animal{ public void move(){ System.out.println("Animal is"); } } class Bird extends Animal{ public void fly(){ System.out.println("Bird is"); } @Override public void move() { //调用父类的无参的构造函数 super.move(); System.out.println("覆盖父类中的方法"); } }
//调用带参数的构造方法
public class Test05 { public static void main(String[] args) { Animal a = new Animal(181,"张三"); Bird b = new Bird(182,"李四",22); } } class Animal{ int num; String name; public Animal(int num, String name) { this.num = num; this.name = name; } } class Bird extends Animal{ int age; public Bird(int num, String name,int age) { //手动调用调用带参数的构造函数 super(num, name); this.age = age; } }
public class Test05 { public static void main(String[] args) { Bird b = new Bird(); b.move(); } } class Animal{ int num; String name; public void move(){ System.out.println("Animal is"); } } class Bird extends Animal{ public void fly(){ //采用 super 调用父类的方法 super.move(); } }
1.14final关键字
final是一个关键字,表示最终的,不可变的 final修饰的类无法被继承,修饰的方法无法被覆盖 修饰的变量一旦被赋值后,不可重新赋值 final修饰的实例变量通常和static联合使用,称为常量
public class Test06 { public static void main(String[] args) { Person p1 = new Person(); //可以赋值 p1.name = "张三"; System.out.println(p1.name); final Person p2 = new Person(); p2.name = "李四"; System.out.println(p2.name); //不能编译通过 //p2 采用 final 修饰,主要限制了 p2 指向堆区中的地址不能修改(也就是 p2 只能指向一个对象) //p2 指向的对象的属性是可以修改的 p2 = new Person(); } } class Person { String name; }
1.15抽象类
public class Test10 { public static void main(String[] args) { MyMath my = null; System.out.println(my.a); My m = new My(); System.out.println(m.dosome(10)); } } interface MyMath{ int a = 10; int dosome(int a); } class My implements MyMath{ public int dosome(int a){ return a; } }
1.18多态
public class User { ……….. } 相当于 public class User extends Object { ……….. }
1.20finalize
1.24内部类
1.24.1实例内部类
public class Test14 { private int a; private int b; Test14(int a, int b) { this.a = a; this.b = b; } //内部类可以使用 private 和 protected 修饰 private class Inner1 { int i1 = 0; int i2 = 1; int i3 = a; int i4 = b; //实例内部类不能采用 static 声明 //static int i5 = 20; } public static void main(String[] args) { Test14.Inner1 inner1 = new Test14(100, 200).new Inner1(); System.out.println(inner1.i1); System.out.println(inner1.i2); System.out.println(inner1.i3); System.out.println(inner1.i4); } }
1.24.1静态内部类
代码:
public class Test15 { static int a = 200; int b = 300; static class Inner2 { //在静态内部类中可以定义实例变量 int i1 = 10; int i2 = 20; //可以定义静态变量 static int i3 = 100; //可以直接使用外部类的静态变量 static int i4 = a; //不能直接引用外部类的实例变量 //int i5 = b; //采用外部类的引用可以取得成员变量的值 int i5 = new Test15().b; } public static void main(String[] args) { Test15.Inner2 inner = new Test15.Inner2(); System.out.println(inner.i1); } }
1.24.3局部内部类
public class Test16 { private int a = 100; //局部变量,在内部类中使用必须采用 final 修饰 public void method1(final int temp) { class Inner3 { int i1 = 10; //可以访问外部类的成员变量 int i2 = a; int i3 = temp; } //使用内部类 Inner3 inner3 = new Inner3(); System.out.println(inner3.i1); System.out.println(inner3.i3); } public static void main(String[] args) { Test16 innerClassTest03 = new Test16(); innerClassTest03.method1(300); } }
1.24.4匿名内部类