面向对象
本质:以类的方式组织代码,以对象的组织(封装)数据
三大特性
- 封装
- 继承
- 多态
构造器
package oop.demo01;
public class Preson {
//一个类即使什么都不写,也会存在一个方法
String name;
//1.使用new关键字,本质是在调用构造器
//2.用来初始化值
public Preson(){
}
//有参构造:一旦定义了有参构造,无参就必须显示定义
public Preson(String name){
this.name=name;
}
/*
构造器:
1.和类名相同
2.没有返回值
作用:
*/
}
封装
package oop.demo04;
/**
* 1.封装的意义
* 2.提高程序的安全性,保护数据
* 3.统一接口
* 4.系统的可维护增加了
*/
public class Student {
//属性私有
/**
* 名字
*/
private String name;
/**
* 学号
*/
private int id;
/**
* 性别
*/
private char sex;
//提供一些可以操作这个属性的方法
public String getName() {
return name;
}
public int getId() {
return id;
}
public char getSex() {
return sex;
}
}
重写
package oop.demo05;
//重写都是方法的重写,和属性无关
public class A extends B{
//@Override 重写
@Override
public void test() {
// super.test();
System.out.println("A=>test()");
}
/*
重写:需要有继承关系,子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符 : 范围可以扩大但不能被缩小
4.抛出的异常 : 范围,可以被缩小,但不能扩大
子类的方法名要跟父类一样,但方法体不同
*/
}
继承
package oop.demo05;
/**
* 继承
* 1.子类继承了父类,就会拥有父类的全部方法
* 2.private 修饰的方法、属性无法被继承
* 3.java中只有单继承、没有多继承
*/
public class Teacher extends Person{
private String name="tk";
public void test(String name){
System.out.println(super.name);
System.out.println(this.name);
}
/*
supper:
1.supper调用父类的构造方法,必须在构造方法的第一个
2.supper必须只能出现在子类的方法或者构造方法中
3.supper和this 不能同时调用构造方法
*/
/*
VS this:
1.代表的对象不同:
this: 本身调用者这个对象
supper: 代表父类对象的应用
前提:
this :没有继承也可以使用
supper :只能在继承条件下才可以使用
构造方法
this() ；本类的构造
supper() : 父类的构造
*/
}
多态
package oop.demo06;
/**
* 多态的注意事项
* 1.多态是方法的多态,属性没有多态
* 2.父类和子类,有联系 类型转换异常! ClassCastException
* 3.存在条件 :继承关系,方法需要重写 ,父类引用指向子类对象!!
*
*
* 1.static 方法属于类,它不属于实例,无法被重写
* 2.final
* 3.private
*/
public class Studernt extends Person{
//instanceof (类型转换)引用类型
}
代码块
package oop.demo07;
public class Person {
{
//代码块
System.out.println("匿名代码块");
}
static {
//静态代码块
//只执行一次
System.out.println("静态代码块");
}
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person=new Person();
System.out.println("==============");
Person person1 =new Person();
}
}
package oop.demo07;
//static
public class Student {
private static int age; //静态的变量
private double score; //非静态的变量
public static void go() {
}
public static void main(String[] args) {
go();
}
}
抽象类
package oop.demo08;
//抽象类的所有方法,继承了他的子类,就必须重写他的方法
public class A extends Action{
@Override
public void doSomething() {
System.out.println("");
}
//1.不能new 这个抽象类,只能靠子类去实现它 :约束
//2.抽象类中可以写普通方法
//3.抽象方法必须在抽象类中
//抽象类存在的意义?
/*
1.提高开发效率,你品
*/
}
package oop.demo08;
//abstract 抽象类 extends : 单继承
public abstract class Action {
//抽象方法,只有方法名字,没有方法的实现
public abstract void doSomething();
}
接口
package oop.demo09;
// 实现了接口的类,就必须重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
System.out.println("add success");
}
@Override
public void delete(String name) {
System.out.println("delete success");
}
@Override
public void time() {
}
}
package oop.demo09;
// interface
public interface UserService {
//默认常量
int AGE=99;
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
/*
作用
1.约束
2.定义了一些方法,让不同的人实现
3.public abstract
4.public static final
5.接口不能被实例话 ,接口中没有构造方法
6.可以实现多个接口
7.必须重写接口中的方法
*/
}
内部类
package oop.demo10;
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 static class Inner{
//
// }
/**
* 局部内部类
*
*/
public void method(){
class Inner{
}
}
/**
* 匿名内部类
*
*/
}
package oop.demo10;
public class TestApp {
public static void main(String[] args) {
Outer outer = new Outer();
// Outer.Inner inner = outer.new Inner();
// inner.in();
// inner.getId();
/**
* 匿名内部类
*
*/
UserService userService = new UserService() {
@Override
public void hello() {
System.out.println("hello");
}
};
}
interface UserService {
void hello();
}
}