一.方法:
1.语法格式:
/*
修饰符 返回值类型 方法名(.....){
//方法体
return 返回值;
}
*/
2.方法类型:
静态方法:含有static修饰
非静态方法:不含有static修饰
调用:
1>.静态方法调用:
类名.方法名
public class Application {
public static void main(String[] args){
Student.study();
}
}
class Student {
public static void study(){
System.out.println("我爱学习Java");
}
}
2>.非静态方法的调用:
实例化类,然后可以进行调用
public class Application {
public static void main(String[] args) {
Student s1 = new Student();//先要对类进行实例化,否则会编译错误
s1.study();
}
}
class Student {
public void study(){
System.out.println("我爱学习Java");
}
}
方法调用时,当两个方法的类型相同时。均为静态类或者非静态类时,可以相互调用;若不同时,非静态类可以调用静态类,但静态类不可以调用非静态类(静态类和类一起加载,静态类加载时,非静态类还没有加载)
3.方法参数:
方法可以修改按引用传递的变量的值,但不能修改按值传递的变量的值
1>.按值调用:(基本数据类型)表示方法接收的是调用者提供的值
public static void main(String[] args) {
int a = 6;
System.out.println(a); //6
System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!");
change(a);
System.out.println(a); //6
}
public static void change(int a){
a = 10;
}
方法得到是所有参数值的一个副本,不能修改传递给它的任何参数变量的内容
2.按引用调用:(对象引用)表示方法接收的是调用者提供的变量的地址
举个例子:
public class Student {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.age);
System.out.println("!!!!!!!!!!!!!!!!!!!!!!");
change(person);
System.out.println(person.age);
}
public static void change(Person person){
person.age = 10;
}
}
class Person{
int age;
}
代码运行
方法得到是对象引用的副本,原来的对象引用和这个副本的引用都指向同一个对象
总结:
1.方法不能修改基本数据类型的参数
2.方法可以改变对象参数的状态
补充:
变量的作用域:
类变量:被static修饰的变量
实例变量:没有被static修饰的变量
局部变量:定义在方法体中的变量
二.类
定义: 类相当于是一个对象的模板,对象就像是类的具体化
举个例子:
public static void main(String[] args){
//类实例化后会返回一个自己的对象!
Student student = new Student();//student对象是一个Student类的具体实例
student.name = "小明";
student.age = 3;
System.out.println(student.name);
System.out.println(student.age);
}
class Student {
String name,
int age;
}
在使用new关键字创建的时候,除了分配内存空间,还会给创建好的对象进行默认的初始化,及对类中构造器的调用
三.构造器
1.构造器的特点:
必须与类的名字相同
没有返回类型,也不能写void
2.构造器的作用:
用来初始化值
初始化数据字段的方法:
1,在构造器中设置值;在使用new关键字创建的时候,除了分配内存空间,还会给创建好的对象进行默认的初始化,及对类中构造器的调用
2,声明中赋值
3,初始化块
3.注意:
仅当类中没有其他任何构造器的时候,才会得到一个默认的无参数构造器;但若在编写了自己一个有参构造器,则必须提供一个无参构造器
4.构造器应用实例:
public class Person {
String name;
int age;
public Person() { //无参构造器
}
public Person(String name,int age) { //有参构造器
this.name = name; //前者是当前类,后者是当前的参数
this.age = age;
}
}
四.封装
1.封装的概念:
将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法对隐藏信息进行访问 实现数据的隐藏
高内聚:类的内部数据操作细节自己完成,不允许外部干涉
低耦合:仅暴露少量的方法给外部使用
2.封装的意义:
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加
3.封装实现的步骤:
设置属性的可见性为:private -> 创建setter/getter方法 -> 在方法中添加属性控制语句
举个例子:
public class Student {
private String name;
private int id;
private char sex;
private int age;
//提供一些可操作的方法,get set
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
//alt + insert
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120||age<0) this.age=3;
else this.age = age;
}
}
五.方法重写:
1.定义:
重写:是父类与子类之间的多态性,实质是对父类函数的重新定义。在子类中定义某方法与其父类有相同的名称和参数则该方法被重写,但子类函数的访问修饰权限不能小于父类;
若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表,则新方法将覆盖原有的方法,如需父类中原有的方法则可使用 super 关键字。
2.重写的注意点:
1.方法名必须相同
2.参数列表必须相同
3.修饰符的范围可以扩大,但不能缩小
4.抛出异常:范围可以被缩小,但不能扩大
注意:静态方法与非静态方法:
静态方法:可以被继承,但不能被覆盖,既不能被重写
非静态方法:可以被重写,但关键词不能是private
举个例子:
//父类代码块
public class B {
public void test(){
System.out.println("B->test");
}
}
//子类代码块
public class A extends B{
//重写
@Override //注解:有功能的注释
public void test() {
System.out.println("A->test");
}
}
//测试代码块
public class Application {
public static void main(String[] args){
A a = new A();
a.test();
//父类的引用指向子类
B b = new A();
b.test();
}
父类引用指向子类对象:
定义了父类B的引用,指向新建的A类型的引用。子类是对父类的一个改进和扩充,所以子类较父类的功能一般更强大,定义父类类型指向子类的可以使子类的功能更加强大,属性较父类更加特别,且可以调用父类中所有的属性和方法,而对于子类中定义而父类中没有的方法,是不可以调用的。
父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法
上述代码的输出结果:
六.继承
1.继承的实现:
语法:class 子类 extends 父类{}
举个例子:
public class Person {
protected String name = "张三";
public void print(){
System.out.println("Person");
}
}
public class Student extends Person{
private String name = "李四";
public void print(){
System.out.println("Studnet");
}
}
注意:子类对象在进行实例化之前,先调用父类中的构造方法,再调用子类中的构造方法实例化子类对象
举个例子:
//父类
public class Person {
public Person() {
System.out.println("Person无参构造执行");
}
}
//子类
public class Student extends Person{
public Student() {
System.out.println("Student无参执行");
}
}
public class Teacher {
public static void main(String[] args){
Student student = new Student();
}
}
补充:1.Java四种权限修饰符
2.super关键字的使用
注意:
1.super调用父类的构造方法,必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
举个例子:
//父类代码
public class Person {
protected String name = "张三";
public void print(){
System.out.println("Person");
}
public Person() {
System.out.println("Person无参构造执行");
}
}
//子类代码
public class Student extends Person{
private String name = "李四";
public void print(){
System.out.println("Student");
}
public void test1(){
print(); //调用当前类
this.print(); //调用当前当前类
super.print(); //调用父类的
}
public void test(String name){
System.out.println(name); //输出传入的名字
System.out.println(this.name); //输出本身调用者的对象的名字
System.out.println(super.name); 输出父类的名字
}
public Student() {
//隐藏代码,调用了父类的无参构造
super();//调用父类构造器,必须在子类的构造器的第一行
System.out.println("Student无参执行");
}
}
//调试代码
public class Teacher {
public static void main(String[] args){
Student student = new Student();
student.test("王五");
student.test1();
}
}
输出结果显示:
总结:继承的限制:
1.子类在进行实例化前首先调用父类的构造方法,再调用子类的构造的方法实例化子类对象
2.Java继承只允许多继承,不允许多继承,即一个子类只能有一个父类,但一个父类可以有多个子类
3.Java继承的时候,子类会继承父类的所有结构,但对于父类私有的不可以直接调用,但可以通过其他方式
七.抽象类
//举个例子:定义一个抽象类
public abstract class Action {
public abstract void doSomething(); //定义了抽象方法
}
注意事项:
1.抽象方法必须为public 或者 protected,若为private则,子类无法继承
2.抽象类的所有方法,其继承子类,都必须要实现,除非子类也是抽象类
3.不能new这个抽象类,只能靠子类去实现它,约束
4.抽象类中可以写普通方法,但是抽象方法必须写在抽象类中
抽象类相比于普通类就多了一些抽象方法,其他部分和普通类相同
由于抽象类中存在一些属性,所以一定存在构造方法。抽象类不可以用final声明,因为其需要子类去继承,如果被final修饰,则不能拥有子类;对于外部抽象类不允许使用static声明,而内部抽象类则可以
八 .多态
1.概念:
按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。
多态的注意事项:
1.多态是方法的多态,属性没有多态。
2.父类和子类之间有联系才可以进行转化
3.存在条件:继承关系 方法需要重写 父类引用指向子类对象
父类引用变量在调用方法的时,会调用子类重写后的方法
2.语法:
父类类型 变量名 = new 子类类型();
3.多态中成员的特点
1>.多态成员变量:编译运行看左边
举个例子:
//父类:
public class Person {
public int num = 10;
public void run(){
System.out.println("run");
}
}
//子类:
public class Student extends Person {
public int num = 15;
@Override
public void run() {
System.out.println("son");
}
}
//调用函数
public class Application {
public static void main(String[] args) {
Student s1 = new Student();//Student能调用的方法都是自己的或者父类的
Person s2 = new Student();//Person 父亲类可以指向子类,但是不能调用子类独有的方法
System.out.println(s2.num);
}
}
输出结果为:10
2>.多态成员方法:编译看左边,运行看右边
举个例子:
//子类和父类的代码如上
//调用函数
public class Application {
public static void main(String[] args) {
Student s1 = new Student();//Student能调用的方法都是自己的或者父类的
Person s2 = new Student();//Person 父亲类可以指向子类,但是不能调用子类独有的方法
s2.run();
s1.run();
}
}
运行结果:
4.instanceof关键字
测试左边的对象是否是右边类或者该类的子类创建的实例对象,是,则返回true,否则返回false。
注意: 返回类型为布尔类型
举个例子:
//父类
public class Person {
}
//子类1
public class Student extends Person {
}
//子类2
public class Teacher extends Person{
}
//测试代码
public class Application {
public static void main(String[] args) {
Object object = new Student();
System.out.println(object instanceof Student);
System.out.println(object instanceof Person);
System.out.println(object instanceof Object);
System.out.println(object instanceof Teacher);
System.out.println(object instanceof String);
//instanceof可以判断不同的类之间是否是父与子的关系,若没有关系则编译会报错
System.out.println("--------------------------------");
Person person = new Student();
System.out.println(person instanceof Student);
System.out.println(person instanceof Person);
System.out.println(person instanceof Object);
System.out.println(person instanceof Teacher);
}
}
运行结果:
5.多态的转型
多态的转型分为向上转型和向下转型两种
向上转型:子类转化为父类
向下转型:父类转化为子类,可能会导致方法的丢失