方法的调用
有static的可以直接调用
没有static的需要将类实例化然后进行调用
public class Student {
//非静态方法，
public void say(){
System.out.println("学生说话了");
}
}
public class Demo01{
public static void main(String[] args){
//对象类型 对象名称 = 对象值
Student student = new student()
student.say()
}
}
一个类中 两个都是静态方法可以直接调用 ，两个都不是静态方法也可以直接调用，但一个是静态方法一个不是静态方法不可以直接调用
public class Demo01{
public static void main(String[] args){
//静态方法是伴随着类的创建便加载
public static void A(){
}
//类实例化才存在
public void B(){
}
}
}
值传递和引用传递
面向对象
三大特性：
继承
封装
多态
类是抽象的，对象，是具体的事物，类是对象的模版
◆使用new关键字创建对象
◆使用new关键字创建的时候，除了分配内存空间之处，还会给创建好的对象进行默认的初始化
◆类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩
个特点：
◆1.必须和类的名字相同
◆2.必须没有返回类型，也不能写void
◆构造器必须要掌握
public class Student {
//属性 字段
String name;
int age;
//方法
public void study(){
//this 指向当前类
System.out.println(this.name+"学生在学习");
}
}
public class Applocation {
public static void main(String[] args) {
//将类实例化，实例化之后将会产生一个返回结果
//类实例化之后，将会产生一个返回对象
//student对象就是Student类的具体实例
Student student = new Student();
Student xiaoming = new Student();
Student xiaohong = new Student();
//给创建的对象赋值
xiaohong.name = "小明";
xiaohong .age = 15;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
}
}
构造器
1，和类名相同
2，没有返回值
作用：
1，new的本质是在调用构造方法
2，初始化对象的值
注意：
1，定义了有参构造，如果想使用无参构造，必须显示的定义一个无参 构造
使用new关键字必须要有构造器，
public class Applocation {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
}
}
public class Person {
String name ;
//可以实例化初试值,this 当前类
public Person(){
this.name = "qinjiang ";
}
}
这里我们的构造器给name赋值是qinjiang ，所以 当我们实例化对象的时候，构造器中的null变为qianjaing
无参构造+有参数构造
this.name 指向的是类中成员变量的name ，=name中的name代表类实例化时候传递进来的name实参数
封装 属性私有get/set
1，Private 保护属性不允许直接赋值，需要配合get读取 set赋值
2， 统一接口形成规范
3，隐藏代码实现细节
4，提高可维护性
command + n 构造set 或 get方法
package com.uchiha.oop.demo04;
public class Student {
//属性私有
private String name ; //名字
private char sex; //性别
private int age; //年龄
//get set提供一些可以操作属性的方法
//set赋值
//get获得数据
//name属性的get方法
public String getName() {
return name;
}
//name属性的set方法
public void setName(String name) {
this.name = name;
}
//age属性的get方法
public int getAge() {
return age;
}
//age属性的set方法
public void setAge(int age) {
//条件判断，如果赋值的age大于小于60 则this到private属性
//然后通过getAge方法由s1对象获取到
if(age>60 || age<3)
this.age = 3;
else {
this.age = age;
}
}
}
package com.uchiha.oop;
import com.uchiha.oop.demo03.Pet;
import com.uchiha.oop.demo04.Student;
public class Applocation {
public static void main(String[] args) {
Student s1 = new Student();
//使用set赋值
//使用get方法获得name属性的值
//
s1.setAge(999);
System.out.println(s1.getAge());
}
}
继承 Extends
1、继承本质上是类和类的关系
2、子类继承父类 子类extends父类
import com.uchiha.oop.Demo05.Student;
public class Applocation {
public static void main(String[] args) {
//将类Student进行实例化
Student student = new Student();
//发现student对象可以调用父类中的say方法
student.say();
}
}
我是父类的方法
子类可以继承父类的属性，但需要注意父类的属性前面的修饰词 private需要使用get/set来操纵
public 公有的
private 私有的
//父类
public class Person {
//父类的属性收到private的保护
private int money = 10_0000_0000;
//父类的方法
public void say(){
System.out.println("我是父类的方法");
}
//定义get/set方法来操纵收到private保护的属性
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
//子类
package com.uchiha.oop.Demo05;
//学生 person的子类
//子类继承父就会拥有父类的全部方法
public class Student extends Person {
}
//其他类
public class Applocation {
public static void main(String[] args) {
Student student = new Student();
//子类使用get方法来获取到父类受到private的属性
System.out.println(student.getMoney());
}
}
1000000000
快捷键查看类结构contral + h
在java中所有类都直接或者间接继承object类。、
super
属性的调用
子类中调用父类的属性可以使用super.父类属性进行调用
package com.uchiha.oop.Demo05;
//person 人 父类
public class Person {
//protected 私有的
protected String name = "父类的属性";
}
package com.uchiha.oop.Demo05;
//学生 person的子类
//子类继承父就会拥有父类的全部方法
public class Student extends Person {
private String name = "类的属性";
public void test(String name){
System.out.println(name); //方法test传递进的name参数
System.out.println(this.name); //当前类的private的name
System.out.println(super.name); //调用的父类的name
}
}
package com.uchiha.oop;
import com.uchiha.oop.Demo05.Student;
public class Applocation {
public static void main(String[] args) {
Student student = new Student();
student.test("调用方法的实参");
}
}
调用方法的实参
类的属性
父类的属性
方法的调用
package com.uchiha.oop.Demo05;
//person 人 父类
public class Person {
public void print(){ //公有的方法pring
System.out.println("父类的方法");
}
}
package com.uchiha.oop.Demo05;
//学生 person的子类
//子类继承父就会拥有父类的全部方法
public class Student extends Person {
public void print(){
System.out.println("子类的方法");
}
public void test(){
print(); //子类中的方法
this.print(); //类中的方法print
super.print(); //父类中的方法pring
}
}
package com.uchiha.oop;
import com.uchiha.oop.Demo05.Student;
public class Applocation {
public static void main(String[] args) {
Student student = new Student();
student.test();
}
}
子类的方法
子类的方法
父类的方法
构造器
1、super调用父类的构造方法，必须在构造方法的第一个
2，super必须只能出现在子类的方法和构造方法中
3，super不能this不能同时调用方法
和this对比
this代表本身调用者的对象
super代表父类对象的引用
this没有继承的情况下也可以使用
super只能在继承条件下使用
构造方法
this默认调用本类的构造方法
super默认调用父类的构造方法
package com.uchiha.oop.Demo05;
//person 人 父类
public class Person {
public Person(){
System.out.println("父类的无参构造器");
}
}
package com.uchiha.oop.Demo05;
//学生 person的子类
//子类继承父就会拥有父类的全部方法
public class Student extends Person {
public Student() {
System.out.println("子类的无参构造执行了");
}
}
package com.uchiha.oop;
import com.uchiha.oop.Demo05.Student;
public class Applocation {
public static void main(String[] args) {
Student student = new Student();
}
}
父类的无参构造器
子类的无参构造执行了
方法重写
1、需要类有继承关系 子类继承父类 子类重写父类的方法
2、参数列表必须相同，否则编程方法重载
3、修饰符范围可以扩大，但不可以缩小 public>protected>default>private
4、跑出的异常范围可以缩小，但不可以扩大 ClassNotFoundException --> Excption(大)
举例
首先 Animal和Cat都具有print方法， Cat继承Animal
package com.uchiha.oop.Demo05;
public class Animal {
public static void print(){
System.out.println("动物可以动");
}
}
---------------------------------------------------
package com.uchiha.oop.Demo05;
public class Cat extends Animal {
public static void print(){
System.out.println("猫可以叫");
}
----------------------------------------------------
package com.uchiha.oop;
import com.uchiha.oop.Demo05.Cat;
import com.uchiha.oop.Demo05.Animal;
public class Applocation {
public static void main(String[] args) {
Cat cat = new Cat();
cat.print();
Animal animal = new Cat();
animal.print();
}
}
猫可以叫
动物可以动
/**虽然animal对象是由Cat类实例出来的，但是方式也指向的是父类，注意这个时候两个方法的修饰词都是public，如果将修饰词都为default那么父类的方法将进行重写
*/
public void print(){
System.out.println("动物可以动");
}
----------------------------------------------------
public void print(){
System.out.println("猫可以叫");
}
}
猫可以叫
猫可以叫
多态
多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象：Parent p = new Child()；
1、多态是方法的多态，属性没有多态
2、父类和子类 类型转换 ClassCastException！
3、多态度存在的条件 有继承关系， 方法需要重写，父类的引用指向子类
4，不能重写的方法 static 、 final 、 private方法
public class Person {
public void run(){
System.out.println("父");
}
}
----------------------------------------------------
public class Student extends Person{
public void run(){
System.out.println("子");
}
public void eat(){
System.out.println("子吃");
}
}
----------------------------------------------------
public class Applocation {
public static void main(String[] args) {
// 一个类的实际类型是确定的
// new Person();
// new Student();
// 但是指向的引用类型就不确定的
Student s2 = new Student();
// 父类的引用 => 子类
Person s1 = new Student();
s1.run();
s2.run();//子类重写父类的方法，将执行子类的方法
((Student) s1).eat(); //父类调用子类的方法默认是调不了的需要类型转换
}
}
子
子
子吃