java:面向对象全代码理解版
java面向对象
1.类和对象的创建
类是一种抽象的数据类型,它是对某一事物的整体定义,对象是一个类的具体的实例。
如人是一个类,而男人女人是他的一个实例对象。
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class SubjectCreate {
//属性
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"正在学习!");
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
SubjectCreate create = new SubjectCreate();
SubjectCreate create1 = new SubjectCreate();
create.name="xiaoming";
create.age=12;
create1.name="xiaohong";
create1.age=18;
System.out.println(create.name);
System.out.println(create.age);
create.study();
System.out.println(create1.name);
System.out.println(create1.age);
create1.study();
}
}
构造器:每个类都有一个默认的构造器,没有返回值,方法名字和类名一样,在使用new关键字的时候必须有一个构造器,才能为该对象注入值。
重载构造器:可以自己定义一个有参构造器,通过该有参构造器在new的时候为对象传值,重写了有参之后就要自己定义无参构造了,否则就不能使用了。
//重载构造器
public SubjectCreate(String name,int age){
this.name=name;
this.age=age;
}
//有参构造器赋值
SubjectCreate create = new SubjectCreate("xiaoming",18);
SubjectCreate create1 = new SubjectCreate("xioahong",89);
create.study();
create1.study();
2.面向对象三大特性
封装:将类中的数据封装起来,只暴露一个接口给对象调用。即将属性私有化,提供set/get方法即可。
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:59
*/
public class Enclosure {
//私有属性
private String name;
private int age;
//set方法
public void setName(String name){
this.name=name;
}
public void setAge(Integer age){
this.age=age;
}
//get方法
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//对私有化属性调用公共方法设置和获取
Enclosure enclosure = new Enclosure();
enclosure.setName("tata");
enclosure.setAge(12);
System.out.println(enclosure.getName());
System.out.println(enclosure.getAge());
}
}
封装可以提高代码的安全性,保护数据。
统一接口
方便调用
继承:一个类通过extends关键字可以继承另一个类,子类就可以拥有父类的所有的属性和方法。
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-21:11
*/
//没有任何属性和方法的儿子定义了继承父类
public class ExtendsSon extends ExtendsFather {
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-21:11
*/
//有属性和方法的父类
public class ExtendsFather {
String name;
String sex;
public void study(){
System.out.println("father正在学习");
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//实例化一个子类,打印出父类的方法
ExtendsSon son = new ExtendsSon();
son.study();
}
}
super关键字与子类重写父类方法
super :为了区别当子类和父类有同名的属性或者方法时,区别到底子类调用的是自己还是父类。super.指向父类的方法或者属性。
super调用父类的构造方法,必须在构造方法的第一个
super必须只能出现在子类的方法中
super和this不能同时调用构造方法
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//实例化一个子类,打印出父类的方法
ExtendsSon son = new ExtendsSon();
System.out.println(son.name);
son.study();
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-21:11
*/
public class ExtendsSon extends ExtendsFather {
String name="son";
//使用super关键字调用了父类中的方法
public void study(){
super.study();
}
}
子类重写父类方法
非静态方法。
public修饰的
重写的方法是子类继承了父类的方法,对父类的方法进行重写。参数和方法名必须相同。
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-14-7:49
*/
public class Son extends Father{
//子类重写父类的test方法
public void test(){
System.out.println("son==>test");
}
}
package com.javase.Subject;
import com.sun.org.apache.xml.internal.res.XMLErrorResources_tr;
/**
* @author panglili
* @create 2022-07-14-7:49
*/
public class Father {
//父类被子类重写的方法
public void test(){
System.out.println("father==>test");
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//父类的引用指向子类
Father father = new Son();
Son son=new Son();
son.test();
father.test();
//输出
// son==>test
// son==>test
}
}
多态:父类的引用指向子类对象
多态必须是具有继承关系的
多态是方法的多态,属性没有多态
方法需要重写,父类就会调用到子类的重写方法
父类要调用子类中有的而自己没有的方法,就会强转为子类。
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//父类的引用指向子类
Father father = new Son();
Son son=new Son();
son.test();
father.test();
//强制类型转换
((Son) father).eat();
//输出
// son==>test
// son==>test
}
}
instanceof关键字:
因为父类转换为子类的时候是向下转型去调用子类方法,是具有父子关系的两个类之间,instanceof关键字就是判断这种父子关系的关键字。
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//父类的引用指向子类
//System.out.println(x instanceof y);
//x和y有父子关系转换才能通过
Father father = new Son();
Father instance = new Instance();
System.out.println(father instanceof Object);//true
System.out.println(father instanceof Father);//true
System.out.println(father instanceof Instance);//false
System.out.println(instance instanceof Father);//true
System.out.println(instance instanceof Son);//false
}
}
5.static
静态的,跟类一起加载。
静态变量:可以直接用类名访问。
静态方法:只能调用静态的属性和方法,因为它先加载在内存中。
静态代码块:会先加载一些初始化作用的数据。
6.抽象类和接口
被abstract修饰的类就叫抽象类。不能被new出来,只能被子类继承。
被abstract修饰的方法就是抽象方法,抽象方法只有方法定义,没有实现,只能由继承它的子类实现,除非继承它的子类也是抽象的。
(1)抽象
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-14-8:50
*/
public abstract class AbstractUse {
//抽象类中的抽象方法,没有实现,只有定义
public abstract void test();
//抽象类中的普通方法,可以有实现
public void test1(){
System.out.println("普通方法");
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-14-8:53
*/
public class AbstractSon extends AbstractUse {
//实现了抽象父类,就必须重写抽象方法
@Override
public void test() {
System.out.println("子类重写的抽象方法");
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//不能new抽象类,只能被继承
// AbstractUse use = new AbstractUse();
AbstractSon son = new AbstractSon();
//子类调用父类的普通方法和抽象方法
son.test();
son.test1();
}
}
(2)接口
使用interface定义替换class类,就定义为一个接口。
接口里面只有抽象方法。
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-14-9:04
*/
public interface Interface {
void add();
void sub();
int mul();
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-14-9:05
*/
public class InterfaceImpl implements Interface {
@Override
public void add() {
System.out.println("实现接口的方法add");
}
@Override
public void sub() {
System.out.println("实现接口的方法sub");
}
@Override
public int mul() {
System.out.println("实现接口的方法mul");
return 0;
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//接口实现类实例化一个对象
InterfaceImpl anInterface = new InterfaceImpl();
anInterface.add();
anInterface.mul();
anInterface.sub();
}
}
7.内部类
在类的内部在创建的类,可以直接获取类的私有属性。
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-14-9:11
*/
public class InterClassUse {
private static int age=10;
public static void test(){
System.out.println("这是一个外部类");
}
public class inter{
public void test1(){
System.out.println("这是一个内部类"+"外部类的值为"+age);
}
}
}
package com.javase.Subject;
/**
* @author panglili
* @create 2022-07-13-20:26
*/
public class Application {
public static void main(String[] args) {
//主启动类
//在此实例化一个类对象
//实例化一个内部类,必须先实例化它的外部类,由外部类实例化内部
InterClassUse interClassUse = new InterClassUse();
InterClassUse.inter inter = interClassUse.new inter();
//内部类可以直接获取外部类的私有属性
inter.test1();
}
}