java面向对象
1 类和对象的创建类是一种抽象的数据类型，它是对某一事物的整体定义，对象是一个类的具体的实例。
如人是一个类，而男人女人是他的一个实例对象。
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();
}
}
