面向对象的本质:以类的方式组织代码,以对象的组织封装数据。
三大特性:封装,继承,多态
回顾方法的定义
package oop;
import java.io.IOError;
import java.io.IOException;
//Demo01类
public class Demo01 {
//main方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名(...){
//方法体
return 返回值;
}
*/
//return 结束方法,返回一个结果
public String sayhello(){
return "helloworld";
}
public void hello() {
return;
}
public int max(int a,int b){
return a>b?a:b;//三元运算符
}
//break:跳出switch,结束循环
//数组下标越界:Arrayindexoutofbounds异常
//异常抛出:后面讲解,IO流读文件会抛出异常
public void readfile(String file)throws IOException{
}
}
回顾方法的调用
![](https://i-blog.csdnimg.cn/blog_migrate/b7dbbce7a6f1c140d326a940c0e3bb13.png)
//遵循一个原则:被static修饰的内容会跟随类的加载而加载,
//所以静态化的内容可以不用实例化就直接调用,同时两个静态方法之间也可以互相调用
//有static的方法属于静态的,没有static的方法属于实例的(类似于变量),
//同时加载的可以相互调用或者先加载的可以调用后加载的,但是后加载的不可以调用先加载的
public static void a(){
b();//静态的不能调用非静态的
}
//类实例化之后才存在
public void b(){
a();//非静态的可以调用静态的
}
public class Demo03 {
public static void main(String[] args) {
int add=new Demo03().add(1,2);
System.out.println(add);
}
public int add(int a,int b){
return a+b;
}
}
public class Demo04 {
//值传递
public static void main(String[] args) {
int a=1;
System.out.println(a);//1
Demo04.change(a);
System.out.println(a);//1
}
public static void change(int a){
a=10;
}
}
//对于基本数据类型来说,给形参传递的是实参值的副本,
// 而对于引用数据类型来说,传递的则是地址的副本。
// 但由于地址的副本和原来的相似,
// 因此传递过去后的形参也指向同一个内存空间中。
public class Demo05 {
//引用传递
//值传递,只是把值传过去了,在函数里修改变量的值,原变量的值不变,引用传递是把地址传过去了,修改变量的值,原变量的值也会变
public static void main(String[] args) {
Person person=new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person.name);//孙孙
}
public static void change(Person person){
person.name="孙孙";
}
}
//定义了一个person类,有一个属性:name
class Person{
String name;
}
类和对象的关系
对象是抽象概念的具体实例。
使用new关键字创建对象。
![](https://i-blog.csdnimg.cn/blog_migrate/f8551f557fb9f3cb22286c4e3a11e012.png)
构造器详解
类中的构造器也称构造方法,是在进行创建对象时必须要调用的,有以下两个特点:1.必须和类名相同;2.必须没有返回类型,也不能写void。
![](https://i-blog.csdnimg.cn/blog_migrate/267af0a0320b615ac8c729a107e731d7.png)
package oop.demo02;
public class Person {
//一个类即使什么都不写,也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//1.使用new关键字,本质是在调用构造器
//2.用来初始化值
public Person(){
}
//有参构造:一旦定义了有参构造,无参构造就必须显示定义
public Person(String name1){
this.name=name1;
}
//快捷键:alt+insert
}
/*
public class Application {
public static void main(String[] args) {
//new实例化一个对象
Person person = new Person("孙孙孙");
System.out.println(person.name);
}
}
构造器:1.和类名相同;2,没有返回值
作用:1.new本质在调用构造方法;2.初始化对象的值
注意:定义有参构造后,如果想使用无参构造,显示的定义一个无参的构造
*/
创建对象内存分析
![](https://i-blog.csdnimg.cn/blog_migrate/03bb3fcfbe8133aa63e6e39436648215.png)
![](https://i-blog.csdnimg.cn/blog_migrate/41c8d376343e47832d02199ef5a16608.png)
封装
该露的露,该藏的藏;高内聚,低耦合;属性私有,get/set。
即类的内部数据操作细节自己完成,不允许外部干涉,且仅暴露少量的方法给外部使用。
public class Studentt {
//属性私有
private String name;
private int id;
private char sex;
private int age;
//提供一些可以操作这个属性的方法
//提供一些public的get,set方法
//get获得这个数据
public String getName(){
return this.name;
}
//set给这个数据赋值
public void setName(String name){
this.name=name;
}
//快捷键:鼠标右键generate
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120||age<0){
this.age=3;
}else {
this.age=age;
}
}
}
/*
public class Application {
//1.提高程序安全性,保护数据
//2.隐藏代码的实现细节
//3.统一接口
//4.系统可维护增加
public static void main(String[] args) {
Studentt s1 = new Studentt();
s1.setName("孙孙");
System.out.println(s1.getName());
s1.setAge(70);
System.out.println(s1.getAge());
}
*/
继承
继承的本质是对某一批类的抽象,extends是扩展,子类是父类的扩展。
继承是类和类之间的一种关系,继承关系的两个类,一个为子类,一个为父类,子类继承父类,使用关键字extends表示。
在Java中类只有单继承,没有多继承。即一个儿子只能有一个爸爸,但是一个爸爸可以有多个儿子。
//在java中,所有的类,都默认直接或间接继承object
public class Personn {
private int money=10000000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
/*
//学生 is 人
//子类继承了父类,就会拥有父类全部的方法
public class Studentdemo extends Personn{
}
*/
/*
//老师 is 人
public class Teacher extends Personn{
}
*/
/*
public class Application {
public static void main(String[] args) {
Studentdemo student = new Studentdemo();
student.say();
student.setMoney(1000000);
System.out.println(student.getMoney());
}
}
*/
super
注意点:
1.super是调用父类的构造方法,必须在构造方法的第一个,默认隐藏
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
super vs this:
代表对象不同:
this:本身调用者对象
super:代表父类对象的引用
前提:
this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法:
this():默认调用本类
super():调用了父类
package oop.demo02;
//人:父类
//在java中,所有的类,都默认直接或间接继承object
public class Personn {
//无参构造器
public Personn() {
System.out.println("person无参执行了");
}
protected String name="孙孙";
//私有的无法被继承
public void print(){
System.out.println("Person");
}
}
package oop.demo02;
//学生 is 人,派生类,子类
//子类继承了父类,就会拥有父类全部的方法
public class Studentdemo extends Personn{
//ctrl+H
public Studentdemo() {
//隐藏代码:默认调用了父类的无参构造:super();//调用父类的构造器,必须在子类构造器的第一行
System.out.println("student无参执行了");
}
private String name="哈哈";
public void print() {
System.out.println("Student");
}
public void test1(){
print();//Student
this.print();//Student
super.print();//person
}
public void test(String name){
System.out.println(name);//伊伊
System.out.println(this.name);//哈哈
System.out.println(super.name);//孙孙
}
}
package oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
Studentdemo student = new Studentdemo();//此时结果为:person无参执行了 student无参执行了
// student.test("伊伊");
// student.test1();
}
}
方法重写
前提:需要有继承关系,子类重写父类的方法。
1.方法名必须相同;
2.参数列表必须相同;
3.修饰符:范围可以扩大,不能缩小。public>protectes>default>private
4.抛出的异常:范围可以被缩小,但不能扩大;ClassNotFoundException->Exception(大) 不行
子类的方法和父类必须一致,但方法体不同。
为什么需要重写:
1.父类的功能子类不一定需要,或者不一定满足;
2.快捷键:鼠标右键Generate ->override
package oop.demo02;
//重写都是方法的重写,和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
package oop.demo02;
public class A extends B{
/*
public void test(){
System.out.println("A=>test()");
}
*/
//快捷键
@Override//重写
public void test() {
System.out.println("A=>test()");
}
}
package oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//静态方法和非静态方法区别很大
//方法的调用只和左边,定义的数据类型有关
A a = new A();
a.test();//A=>test()
//父类的引用指向了子类
B b=new A();//非静态:子类重写了父类的方法
b.test();//B=>test(),非静态时结果为A=>test()
}
}
多态
即同一个方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的,但可以指向对象的引用类型有很多(父类,有关系的类)
注意事项:
1.多态是方法的,属性没有多态;
2.父类和子类,有联系,类型转换异常,ClassCasstException;
3.存在条件:有继承关系,方法需要重写,父类引用指向子类对象;
有些方法不能被重写:
1.static方法,属于类
2.final 常量;
3.private方法
//父类
public class C {
public void run(){
System.out.println("run");
}
}
//子类
public class D extends C{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
D d = new D();
//可以指向的引用类型就不确定了,父类的引用指向子类
C d1 = new D();
Object d2 = new D();
//对象能执行哪些方法主要看对象左边的类型,和右边无关
//D子类能调用的方法都是自己的或者是继承父类的
d1.run();//run//son,子类重写了父类的方法,执行子类的方法
d.run();//son
//C父类可以指向子类,但不能调用子类独有的方法
d.eat();
((D)d1).eat();//强制转换,高转低
//d1.eat();错误,因为父类没有eat方法
}
}
instanceof
public static void main(String[] args) {
//instanceof作用是看左边和右边是否有父子关系
//Object>String
//Object>Person>Teacher
//Object>Person>Student
Object object = new Student();
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
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//false,编译报错
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//false,报错
//System.out.println(student instanceof String);//false,报错
}
强制转换
//Person类里有go方法
//高转低
Person obj=new Student();
((Student)obj).go();
//低转高,子类转父类,可能会丢失自己本来的一些方法
Student student=new Student();
Person person=student;
person.go();//报错
static关键字
//public final class Teacher 被final修饰的类,不能被继承,断子绝孙
public class Teacher{
private static int age;//静态的变量,多线程用到
private double score;//非静态的变量
public void run(){
go();//非静态方法可以调用静态方法里的东西
}
public static void go(){
}
public static void main(String[] args) {
Teacher teacher = new Teacher();
System.out.println(Teacher.age);
//静态变量对于类而言只有一个,可以被类中的实例去共享
System.out.println(teacher.age);
System.out.println(teacher.score);
//静态方法可以调用静态方法的,但不能调用非静态方法的
go();
//run();报错
}
{
//匿名代码块,在构造器之前,和对象同时产生,用来赋初始值
System.out.println("匿名代码块");//第二个
}
static {
//静态代码块,类一加载就执行,只执行一次
System.out.println("静态代码块");//第一个被输出,只执行一次
}
public Teacher() {
System.out.println("构造器");//第三个
}
}
抽象类
1.不能new抽象类,只能靠子类去实现它,是一个约束;
2.抽象类里可以写普通方法;
3.抽象方法必须在抽象类中;
4.抽象类存在构造器,new子类会自动执行父类构造。
//abstract 抽象类
//java类是单继承的,但是接口可以实现多继承
public abstract class Action {
//只有方法名字,没有方法实现
public abstract void run();
}
//继承了抽象类的子类,必须要实现抽象类(父类)中的抽象方法。(自己的梦想实现不了,交给儿子),除非子类也是抽象类
public class B extends Action{
@Override
public void run() {
}
}
接口
只有规范(抽象方法),自己无法写方法。约束和实现分离。接口的本质是契约,就像法律一样,制定好后大家都遵守。声明接口的关键字是interface。
作用:
1.约束;
2.定义方法,让不同的人实现;
3.方法都是public abstract;
4.常量都是public static final;
5.接口不能被实例化,没有构造方法;
6.implements可以实现多个接口;
7.必须要重写接口中的方法;
public interface UserService {
//接口中的所有定义都是抽象的,接口都需要有实现类
//直接写返回值类型 方法名 参数
//下面定义了四个方法
void add(String name);
void delete(String name);
void change(String name);
void select(String name);
}
//另一个接口
public interface TimeService {
void timer();
}
//接口的实现类一般以Impl结尾,使用implements关键词
//alt+enter快捷键,如果要实现接口里的所有定义,必须要重写所有方法
//多继承:利用接口实现
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void change(String name) {
}
@Override
public void select(String name) {
}
@Override
public void timer() {
}
}
内部类
内部类就是在一个类的内部再定义一个类,比如,A类中定义一个B类,那么B类相对A类就称为内部类,而A类相对于B类来说就是外部类。
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
//局部内部类
class Inner2{
}
}
//内部类
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void gerID(){
System.out.println(id);
}
}
}
//一个Java类中可以有多个class类,但只能有一个public class
class A{
//可以写测试类,因为可以写main方法
public static void main(String[] args) {
}
}
public class Test {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();//这是内部类的方法
inner.gerID();//10,//获得外部类的私有属性
}
}