面向对象编程的本质是：以类的方式组织代码，以对象的形式封装数据。
三大特性：封装、继承、多态
从认识论角度先有对象后有类
从代码运行角度先有类后有对象
静态方法
public class Demo02 {
/* 静态方法 static
调用时 类名+方法名
Student.say();
*/
/*非静态方法
实例化这个类：对象类型 对象名 = 对象值；
Student student = new Student();
student.say();
*/
}构造器
alt+insert constructor 生成构造器
-
ok 有参
-
select none 无参
无参
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person();
System.out.println(person.name);
}
}
==================================
public class Person {
/*一个类即使什么都不写，它也会存在一个方法
即构造器构造的无参方法：
1.方法名和类名相同
2.没有返回值，不写void
*/
String name;
//实例化初始值
//1.使用 new 关键字，本质实在调用构造器
//2.构造器一般用来初始化值
public Person(){ //无参
this.name = "傻逼孙宇婷";
}
}有参
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person("傻逼孙宇婷");
System.out.println(person.name);
}
}
==============================
public class Person {
String name;
public Person() {
}
//有参构造: 一旦定义了有参构造，使用无参构造就必须显式定义一个无参构造
public Person(String name) {
this.name = name;
}
}this.name(当前类) = name(参数传进来的值);
对象的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈--->堆（地址）
属性
字段Field 成员变量
默认初始化：
数字： 0 0.0
char: u0000
boolean : false
引用： null
修饰符 属性类型 属性名 = 属性值
封装(数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过相应的接口来访问，这称为信息隐藏
Alt + Insert get、set 方法
1.提高程序安全性，保护数据
2.隐藏代码的实现细节
3.统一接口，get、set
4.增加系统的可维护性
继承
在java中，所有的类，都默认直接或间接继承Object
java中类只有单继承，没有多继承
私有的东西无法被继承
super:
1.调用父类的构造方法，必须在子类构造器的第一行（子类构造器默认调用父类构造器），super只能出现在子类的方法或构造方法中
2.父类没有无参构造，子类不能调用无参（super()）
3.super和this 不能同时调用构造方法
VS this
代表的对象不同：
this ：本身调用者这个对象
super : 代表父类对象的应用
前提：
this ：没有继承也可以使用
super： 只能在继承条件下才可以使用
构造方法：
this(); 本类的构造
super();父类的构造
重写
重写是方法的重写，与属性无关
静态方法的调用只和左边定义的数据类型有关
父类的引用可以指向子类，输出还是父类。
静态方法
B b = new A();//A是B的子类
b.test();//调用结果仍为BOverride 重写
alt + Insert
@Override //注解：有功能的注释重写只与非静态方法有关
非静态方法
B b = new A();//A是B的子类
b.test();//调用结果为A子类重写了父类的方法，执行子类的方法
重写：需要有继承关系，子类重写父类的方法，只在public 下
1.方法名必须相同，方法里面的内容可以不同
2.参数列表必须相同
3.修饰符：范围可以扩大，不能缩小 public > Protected > Default > private
4.抛出的异常：范围可以被缩小，但不能扩大
为什么需要重写？父类的方法子类不一定需要，或者不一定满足
多态：同一方法可以根据对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但是可以指向的类型就不确定了
子类能调用的方法都是自己的或继承父类的
父类能指向子类，但是不能调用子类独有的方法
对象能执行哪些方法，主要看对象左边的类型，与右边关系不大
Student s1 = new Student();
Person s2 = new Student();//父类的引用指向子类的对象
Object s3 = new Student();注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类转换有联系，否则类型转换异常。ClassCastException
3.存在条件：继承关系，子类重写父类方法，父类引用指向子类对象
不能重写：static,final,private
instanceof 类型转换
X instanceof Y 有父子关系返回true，没有返回false，没有关系编译错误
子类转换为父类可能丢失自己本来的一些方法
子类转换为父类，向上转换 Person person = student;
父类转换为子类，向下转换，强制转换 Student student = (Student) person
//静态导入包
import static java.lang.Math.random;
//2.赋初始值
{
System.out.println("匿名代码块");
}
//1.只执行一次
static{
System.out.println("静态代码块");
}
//3.
public Person() {
System.out.println("构造方法");
}abstract，抽象类
abstract , 抽象方法，只有方法名字，没有方法的实现
抽象类的所有方法，继承了它 的子类，都必须要实现它的方法
1.不能new 这个抽象类，只能靠子类去实现它
2.抽象方法必须在抽象类中
3.抽象类中可以写普通方法
接口
作用：1.约束
2.定义一些方法，让不同的人实现
3.接口中所有定义都是抽象的，方法都是public abstract（省略）
4.常量 public static final（省略）
5.接口不能被实例化，接口中没有构造方法
6.implements 可以实现多个接口
7.类中必须要重写接口中的方法
内部类：在一个类的内部再定义一个类
一个java类中可以有多个class类，但只能有一个public class类
匿名内部类：new Apple().eat();没有名字初始化类，不用将实例保存到变量中
内部类可以获得外部类的私有属性
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();异常
try{ //监控区域
System.out.println(a/b);
}
catch(ArithmeticException e){ //捕获异常
System.out.println("程序出现异常，变量b不能为0");
}finally{ //处理善后工作
System.out.println("finally");
}catch里面的参数为想要捕获的异常类型
Throwable能捕获所有Error和Exception
假设要捕获多个异常，从小到大
Ctrl + Alt + T 自动生成try catch + finally
//假设这个方法中，处理不了这个异常，方法上抛出异常
public void test(int a,int b) throws ArithmeticException{
if(b==0){
throw new ArithmeticException(); //主动抛出异常，一般在方法中使用
}
System.out.println(a/b);
}
扫一扫
1781
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
