面向对象
1.什么是面向对象
2.引用传递
//引用传递:对象,本质还是值传递
public class Demo1 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
change(person);
System.out.println(person.name);//小天
}
public static void change(Person person) {
person.name = "小天";
}
}
//定义一个Person类,有一个属性:name
class Person{
String name;//默认值为null
}
3.类与对象的创建
3.1类与对象的关系
3.2创建与初始化对象
//Student类
public class Student {
//属性:字段
String name;//null
int age;//0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
//一个项目应该只有一个主方法
public class Application {
public static void main(String[] args) {
//类是抽象的,需要实例化
//类实例化后会返回一个自己的对象!
//student对象就是一个Student类的具体事例!
//Student student = new Student();
Student xm = new Student();
Student xh = new Student();
xm.name = "小明";
xm.age = 3;
System.out.println(xm.name);
System.out.println(xm.age);
xh.name = "小红";
xh.age = 3;
System.out.println(xh.name);
System.out.println(xh.age);
xh.study();//xh.study则小红在学习
xm.study();
}
}
4.构造器详解
public class Person {
//一个类即使什么都不写,它也会存在一个方法
//显式的定义构造器(方法)
String name;
//实例化初始值
//1. 使用new关键字,本质是在调用构造器
public Person(){
}
//有参构造:一旦定义了有参构造,无参就必须显式定义
//同时是方法的重载
public Person(String name){
this.name = name;
}
//alt+Ins可以快速生成构造器
}
/*
public static void main(String[] args) {
//new实例化了一个对象
Person person = new Person("xiaotian");
System.out.println(person.name);
}
构造器:
1. 和类名相同
2. 没有返回值
作用:
1. new 本质是在调用构造方法
2. 初始化对象的值
注意点:
1. 定义有参构造之后,如果想使用无参构造,必须显式定义一个无参构造
alt+Ins快捷生成构造器(构造方法)
*/
5.类和对象的小结
5.1类与对象
类:是一个模版,是抽象的
对象:是一个具体的实例
5.2方法
定义和使用
5.3对应的引用
- 引用类型
- 基本类型(八种)
对象是通过引用来操作的:栈----->堆
5.4属性:字段Field 成员变量
默认初始化:
- 数字类:0 0.0
- char:u0000
- boolean:false
- 所有引用:null
定义:
修饰符 属性类型 属性名 = 属性值
5.5对象的创建和使用
- 必须使用new 关键字创建对象,构造器 Person xiaotian = new Person();
- 对象的属性:xiaotian.name
- 对象的方法:xiaotian.sleep()
5.6类
- 静态的属性:属性
- 动态的行为:方法
6.封装
7.继承
8.Super详解
8.1super注意点
(1)super调用父类的构造方法,必须在构造方法的里的第一行
(2)super必须只能出现在子类的方法或者构造方法中
(3)super和this不能同时调用构造方法
8.2super与this 的不同
(1)代表的对象不同:
this:本身调用这个对象
super:代表父类对象的引用
(2)前提:
this:没有继承也可以使用
super:代表父类对象的引用
(3)构造方法
this():调用本类的构造
super():调用父类的构造
9.方法重写
需要有继承的关系,子类重写父类的方法
(1)方法名必须相同
(2)参数列表必须相同
(3)修饰符:范围可以扩大但不能缩小 public > protected > default >private
(4)抛出的异常:范围可以被缩小,但不能扩大
重写:子类的方法和父类必须要一致,方法体 不同
重写的需要:父类的功能子类不一定需要或不一定满足 alt+Ins :override
10.多态
(1)父类引用指向子类的对象
(2)把子类转换为父类,向上转型
(3)把父类转型为子类,向下转型(强制转换)会丢失自己本来的方法
(4)方便方法的调用,减少重复的代码,简洁
11.instanceof
public class Application {
public static void main(String[] args) {
//Object > String
//Object > Person > Teacher
//Object > Person > Student
//System.out.println(X instanceof Y);//能不能编译通过看X和Y有没有父子关系
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
System.out.println("---------------------------");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//编译不通过
System.out.println("----------------------------");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译不通过
//System.out.println(student instanceof String);//编译不通过
}
}
12.static详解
//static
public class Student extends Person {
private static int age;//静态变量 多线程
private double score;//非静态变量
public void run(){
}
public static void go(){
}
public static void main(String[] args){
Student s1 = new Student();
System.out.println(Student.age);//静态变量用类名调用
//System.out.println(Student.score);//非静态变量不能用类名调用
System.out.println(s1.age);
System.out.println(s1.age);
//run();//直接调用run()方法不行,不是静态方法
new Student().run();
go();//或
Student.go();//static和类一起加载出来,所以可以调用
}
}
public class Person {
//第二个执行,赋初始值
{
//匿名代码块,创建对象时就创建了,在构造器之前
System.out.println("匿名代码块");
}
//第一个执行,值执行一次
static{
//静态代码块,跟类加载一起执行,值执行一次
System.out.println("静态代码块");
}
//第三个执行
public Person(){
//构造方法
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("--------------------");
Person person2 = new Person();
}
}
运行结果:
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
13.抽象类
//abstract 抽象类 类的继承是单继承 (接口可以多继承)
public abstract class Action {
//约束~有人帮我们实现~
//abstract,抽象方法,只有方法名字,没有方法的实现
public abstract void doSomething();
//1.不能new这个抽象类,只能靠子类去实现它:约束
//2.抽象类中可以写普通的方法
//3.抽象方法必须在抽象类中
//抽象的抽象:约束
//思考:
/*
1.抽象类是否存在构造器:有
2.存在的意义 抽象出共同的东西 提高开发效率
*/
}
public class A extends Action{
@Override
public void doSomething() {
//子类实现抽象类中的抽象方法
}
}
14.接口
//类 可以实现接口 ,implement接口
//实现了接口的类,就需要重写接口中的方法
//多继承 通过结果实现
public class UserServiceImpl implements UserService,TimeService {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
//抽象的思维~ Java架构师
//interface定义关键字 , 接口都需要有实现类
public interface UserService {
//接口中的所有定义都是抽象的 public abstract
//常量 public static final
int AGE = 98;
//方法public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void timer();
}
14.1接口的作用
(1)约束
(2)定义一些方法,让不同的人呢实现
(3)方法只写类型加方法名 (被public abstract自动修饰)
(4)常量只写类型加名称(被public static fianl自动修饰)
(5)接口不能被实例化,接口没有构造方法
(6)implements可以实现多个接口,用,分隔
(7)类实现接口必须重写其方法
14.2内部类
一个java类中可以有多个class类,但是只能有有一个public class
public class Outer {
private int id = 0;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
}
}