1.java值传递
Java 中的基本类型,属于值传递。
Java 中的引用类型,属于引用传递。
Java 中的 String 及包装类,属于特殊群体,作为形参时,由于每次赋值都相当于重新创建了对象,因此看起来像值传递,但是其特性已经破坏了,值传递、引用传递的定义。因此他们属于引用传递的定义,却表现为值传递。
String 与其他包装类,在做形参的时候,由于他们在赋不同于实参的值时,改变了形参的地址,因此使引用传递,看起来像值传递,其实本质还是引用传递
2.方法重写
重写:需要有继承关系,子类重写父类的方法 1.方法名相同 2.参数列表相同 3.修饰符: 范围可以扩大 public > protected > Default > private 4.抛出的异常 : 范围可以缩小 ,但是不能扩大 , ClassNotFoundException --> Exception(大)
重写 :子类的方法和父类必要一致 :方法体不同
为什么要重写 1.父类的功能不一定能满足,或者需要
3.多态
多态注意事项: 1.多态是方法的多态 2.父类和子类要有联系 3.存在条件: 继承关系,方法需要重写,父类引用指向子类对象 Father f1 = new Son(); 4.static方法: 属于类,不属于实例
//一个对象的实际类型确定的
//new Student();
//new person();
//可以指向的引用类型不确定: 父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person 父类型,可以指向子类,但是不能调用子类独有的方法####################
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法,只要看对象左边的类型,和右边关系不大
//左边哪个类型就执行哪个类的,如果都有这个方法的话就执行子类的
s1.eat();//子类重写了父类方法,执行子类的方法,son
((Student) s2).eat();
4.instanceof
//instanceof 判断类之间是否相似
//Object > String
//Object > Person > Teacher
//Object > Person > Student
Object object = new Student();
//System.out.println();
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
5.类型转换
package oop.demo04;
/**
* 类型转换
* 1.父类引用指向子类的对象
* 2.把子类转换成父类,向上转换
* 3.把父类转换成子类,向下转换,强制转换
* 4.方便方法的调用,减少代码量
*/
public class Application {
public static void main(String[] args) {
// 高Person 低Student
Person obj = new Student();
//obj无法使用子类go()方法;
Student student = (Student) obj;//强制转换高---->低
student.go();//可以使用子类的go方法
//子类转换成父类可能丢失自己本来的一些方法
Student student1 = new Student();
student1.go();
Person person = student1;
//person.go
}
}
6.静态代码块
package oop.demo05;
public class Person {
//1.静态代码块只执行一次
static {
System.out.println("静态代码块");
}
//2.赋初始值
{
//代码块(匿名代码块)
System.out.println("匿名代码块");
}
//3
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("===========");
Person person1 = new Person();
}
}
执行结果:
静态代码块 匿名代码块 构造方法 =========== 匿名代码块 构造方法
//静态导入包 import static java.lang.Math.random;
7.抽象类
package oop.demo06;
/**
*abstract抽象类:
*/
public abstract class Action {
//约束——有人帮我们实现~
//abstract ,抽象方法,只有方法和名字,没有方法实现
public abstract void doSomething();
//1.不能new这个抽象类,只能靠子类去实现它,约束
//2.抽象类中可以有普通方法
//3.抽象方法只能在抽象类中
//抽象的抽象
//抽象类? 提高开发效率
}
8.接口
package oop.demo07;
/**
* 接口里面的方法都是抽象的 public abstract
* 1.约束
* 2.定义一些方法不同人实现
* 3.接口可以用implements 实现多个接口
* 4.接口没有构造函数
*/
public interface UserService {
//常量public static final
int AGE = 99;
public void addUser();
public void deleteUser();
public void updateUser();
public void queryUser();
}
9.内部类
package oop.demo08;
/**
* 1.内部类
* 2.一个java类中可以有多个class类,但是只能有一个public class
*/
public class Outer {
private int id;
public void out(){
System.out.println("这是外部类的方法");
}
/* static 如果用static修饰id也需要为static才能访问 */ class Inter{
public void inter(){
System.out.println("这是内部类方法");
}
//获取外部类的私有属性
public void getId(){
System.out.println(id);
}
//局部内部类
public void method(){
class in{
}
}
}
}
10.异常
package oop.demo09;
/**
* 异常处理
*/
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
//假设要捕获异常,要从小到大!
try { //监视区域
//System.out.println(a/b);
new Test().a();
} catch (Error error){ //捕获异常,参数是想要捕获的异常类型
System.out.println("Error");
} catch (Exception exception){
System.out.println("Exception");
} catch (Throwable throwable){ //最大的写在最后
System.out.println("Throwable");
} finally { //处理善后工作,可以不要 ,后续IO操作,需要关闭IO流等
System.out.println("finally");
}
}
public void a(){
b();
}
public void b(){
a();
}
}
11.继承
package oop.extend;
//学生 is 人 :子类 ,派生类
//子类继承父类,会拥有父类全部方法
/*
super注意点:
1.super 调用父类的构造方法, 必须放在构造方法第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super和this 不能同时调用构造方法
前提:
this: 可以在无继承时使用
super: 必须存在继承条件才可以使用
构造方法:
this() :本类的构造
super() :父类的构造
*/
public class Student extends Person {
//ctrl + H
private String name = "huishneg";
public Student() {
//隐藏代码,调用了父类的无参构造
//super();必须子类构造器第一行
System.out.println("student无参数执行了");
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
//可以用super访问用protected修饰的属性
System.out.println(super.name);
}
public void say(){
System.out.println("Student说话了");
}
public void print(){
System.out.println("Student");
}
public void test1(){
print();//Student
this.print();//Student
super.print();//Person
}
}