面向对象
static
static 方法调用非静态方法是会报错
原因:static是跟类同时加载的,时间线很高,当调用还未加载的非静态方法时就会报错。
public class StaticTest {
public static void main(String[] args) {
}
public static void a(){
// b();//报错
new StaticTest().b();
}
public void b(){
}
}
Java的值传递和引用传递
//值传递
public class Demo02 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);//a = 1
change(a);
System.out.println(a);//a = 1
}
/**
* 值传递
* @param a
*/
private static void change(int a) {
a = 10;
}
}
//引用传递
public class Demo03 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
change(person);
System.out.println(person.name);//王睿
}
private static void change(Person person) {
person.name = "王睿";
}
}
class Person{
String name;
}
构造器(构造函数)
作用:
- 实例化初始化
- 使用new关键字,本质是在调用构造器
- 一旦定义了有参构造,无参构造就必须显式定义
public class Person{
//一个类及时什么都不写,它也会存在一个方法
//显式地定义构造器
String name;
//实例化初始值
//1.使用new关键字,本质是在调用构造器
public Person(){
}
//有参构造:一旦定义了有参构造,无参就必须显式定义
public Person(String name){
this.name = name;
}
}
封装(属性私有)
作用:
- 提高程序的安全性,保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性增加
继承
super
注意点:
- super调用父类的构造方法,必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
VS this:
代表的对象不同:
this:本身调用这个对象
super:代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件下才可以使用
构造方法
this:本类的构造
super:父类的构造
重写
需要有继承关系,子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大
public>protected>default>private
- 抛出的异常:范围,可以被缩小,但不能被扩大
重写,子类的方法和父类必须一致,方法体不同。
为什么需要重写:
1. 父类的功能,子类不一定需要,或者不一定满足
2. Alt+Insert:override;
多态
什么是多态
多态是同一个行为具有多个不同表现形式或形态的能力
多态就是同一个借口,使用不同的实例而执行不同操作
多态举例
public class Test{
public static void main(String[] args){
show(new Cat());//以Cat对象调用show方法
show(new Dog());//以Dog对象调用show方法
Animal a = new Cat(); //向上转型
a.eat(); //调用的是Cat的eat
Cat c = (Cat)a; //向下转型
c.work(); //调用的是Cat的work
}
public static void show(Animal a){
a.eat();
//类型判断
if(a instanceof Cat){
Cat c = (Cat)a;
c.work();
}else if(a instanceof Dog){
Dog d = (Dog)a;
d.work();
}
}
}
abstract class Animal{
abstract void eat();
}
class Cat extends Animal{
public void eat() {
System.out.println("Eat Fish");
}
public void work(){
System.out.println("Catch mouse");
}
}
class Dog extends Animal{
public void eat() {
System.out.println("Eat Bone");
}
public void work(){
System.out.println("Looking for the House");
}
}
多态性的具体表现
比如Windows电脑中按下F1键这个动作:
- 如果在Flash界面下弹出的就是AS 3的帮助文档;
- 如果当前在Word下弹出的就是Word帮助
- 在Windows下弹出的就是Windows的帮助和支持
注意事项:
-
多态是方法的多态,属性没有多态
-
父类和子类,有联系 类型转换异常
-
存在条件:继承关系,方法需要重写,父类引用指向子类对象 Father f1 = new Son();
static 方法,属于类,它不属于实例
final 常量
private方法
//父类
public class Father{
public void run{
System.out.println("Father Run");
}
}
//子类
public class Son extends Father{
@Override
public void run{
System.out.println("Son Run");
}
public void eat{
System.out.println("Son Eat");
}
}
//测试类
public class Test{
public static void main(String[] args){
//对象能执行哪些方法,主要看左边的类型,和右边的关系不大
Son son = new Son();//Son 可以执行Son本身和从Father那里继承的方法
Father fa = new Son();//Father可以执行本身的方法,但是不能执行子类特有的方法
son.run();//输出:Son Run
fa.run();//输出:Son Run,子类重写父类的方法,则执行子类的方法
son.eat();//输出:Son Eat
// fa.eat();//报错,原因:父类不可以调用子类独有的方法
((Son)fa).eat();//进行类型转换之后,输出:Son Eat
}
}
/**
* 1.子类能调用的方法是都是自己的或者继承父类的
* 2.父类能调用的方法是自己的 ,不能调用子类独有的方法
* 3.如果子类对父类的方法进行重写,则执行子类的方法
*/
父类引用指向子类的对象
Person person = new Student();
把子类转换为父类,向上转型
把父类转化为子类,向下转型,强制转型
方便方法的调用,减少重复代码,简洁
抽象:封装、继承、多态
抽象类
public abstract class Action {
//抽象方法,只有名字,没有实现
public abstract void doSomething();
//1.不能new这个抽象类,只能靠子类去实现它:约束
//2.抽象类中可以写普通的方法
//3.抽象方法必须在抽象类中
//抽象的抽象:约束
}
public class A extends Action{
@Override
public void doSomething() {
}
}
接口
public interface UserService {
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public class UserServiceImpl implements UserService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
- 约束
- 定义一些方法,让不同的人实现
- public abstract
- public static final
- 接口不能被实例化,接口中没有构造方法
- implements可以实现多个接口
- 必须要重写接口中的方法
内部类
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
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.getID();
}
}