palabra clave final
La palabra clave final es el significado final y se puede modificar (método, variable, clase)
Características de la modificación final.
Método de modificación: indica que el método es el método final y no se puede anular
Variable modificada: indica que la variable es una constante y no se puede volver a asignar
Clase modificada: indica que la clase es la clase final y no se puede heredar
/ Las variables se almacenan en la pila
/ las cosas nuevas se almacenan en el montón
基本数据类型变量:其值不能被更改
//常量的命名规范:如果是一个单词,所有字母大写,如果是多个单词,所有字母大写
//但中间需要使用_分隔
final int NAX = 10;
final int MAX_VALUE = 20;
引用数据类型变量:内存地址不能被更改,但是可以修改对象的属性值
final Student stu = new Student();
stu.setName("张三");
stu.setName("李四");
//final修饰成员变量 初始化时机
//1.在创建的时候,直接给值
//2.在构造方法结束之前,完成赋值
Bloque de código :
El código entre {} se llama bloque de código.
Bloque de código parcial:
Ubicación: definida en el método
Función: limitar el ciclo de vida de las variables, publicarlas antes y mejorar la utilización de la memoria
Construir bloque de código:
Ubicación: fuera del método en la clase
Características: Cada vez que se ejecuta el método de construcción, el bloque de código se ejecutará y ejecutará antes de que se ejecute el método de construcción.
Función: extraiga el mismo código en varios métodos de construcción en el bloque de código de construcción para mejorar la reutilización del código
Bloque de código estático:
Ubicación: fuera del método en la clase
Características: debe ser modificado por la palabra clave estática, cargado con la carga de la clase y solo ejecutado una vez
Función: realiza algunas operaciones de inicialización de datos cuando se carga la clase, generalmente se usa para instalar el controlador
interfaz:
Darse cuenta más
Cuando todos los métodos de una clase son métodos abstractos, podemos definirlos como interfaces
La interfaz también es un tipo de datos de referencia, es más abstracta que la clase abstracta
Dos significados importantes de la existencia de interfaces
1. Definición de reglas
2. Ampliación del programa
Definición y características de la interfaz:
La interfaz se define con la interfaz de palabras clave
nombre de la interfaz de interfaz pública {}
No se puede crear una instancia de la interfaz
Existe una relación de implementación entre una interfaz y una clase, que está representada por la palabra clave implements
nombre de clase de clase pública implementa el nombre de la interfaz {}
Subclase de interfaz (clase de implementación)
O reescribe todos los métodos abstractos en la interfaz
O una clase abstracta
ejemplo:
public class Demo1 {
public static void main(String[] args) {
Cat c = new Cat();
c.catchMouse();
Dog d = new Dog();
d.catchMouse();
}
}
interface CM{
public abstract void catchMouse();//抽象方法
}
class Cat implements CM{
//接口实现
@Override
public void catchMouse() {
//重写方法
System.out.println("猫抓老鼠");
}
}
class Dog implements CM{
//接口实现
@Override
public void catchMouse() {
//重写方法
System.out.println("狗拿耗子");
}
}
Nota: La relación de implementación entre interfaces y clases se puede implementar individualmente o en implementaciones múltiples.
clase pública nombre de clase implementa la interfaz 1, interfaz 2 {}
public class Test1Interface {
/*
接口定义格式:
public interface 接口名{}
类实现接口的格式:
public class 类名 implements 接口名{}
*/
public static void main(String[] args) {
//Inter i = new Inter();接口不允许创建对象
InterImpl ii = new InterImpl();
ii.study();
}
}
public class InterImpl implements Inter,InterA{
@Override
public void study() {
System.out.println("我是实现类中的study方法");
}
@Override
public void print1() {
}
@Override
public void print2() {
}
}
public interface Inter {
public abstract void study();
}
public interface InterA {
public abstract void print1();
public abstract void print2();
}
Características de los miembros en la interfaz:
Variables de miembro:
接口中成员变量只能是常量
系统会默认加入三个关键字:public static final
Método de construcción:
No en la interfaz
Método de miembro:
Método de miembro: solo método abstracto, el sistema utilizará por defecto dos palabras clave
resumen público
public class TestInterface {
/*
接口中成员变量只能是常量,系统会默认加入三个关键字
public static final
构造方法:接口中没有
成员方法:只能是抽象方法,系统会默认给两个关键字
public abstract
*/
public static void main(String[] args) {
System.out.println(Inter.NUM);
}
}
class InterImpl extends Object implements Inter{
//所有的类默认的父类是Object
public InterImpl(){
super();
}
public void method(){
//num = 20;
System.out.println(NUM);
}
@Override
public void show() {
}
}
interface Inter {
//接口中的变量是常量,默认会被final,static,public关键字修饰
public static final int NUM = 10;
//public Inter(){}
public abstract void show();
}
Características de los miembros de la interfaz en la versión JDK8:
Después de la versión JDK8:
1. Está permitido definir métodos no abstractos en la interfaz, pero debe modificarse con la palabra clave predeterminada, estos métodos son métodos predeterminados
Función: resolver el problema de la actualización de la interfaz
2. Se permite definir el método estático estático en la interfaz
El formato de definición del método predeterminado en la interfaz:
Formato: nombre de método de tipo de valor de retorno predeterminado público (lista de parámetros) ()
Ejemplo: public default void show () ()
Notas sobre el método predeterminado en la interfaz:
El método predeterminado no es un método abstracto, por lo que no es obligatorio reescribirlo. Pero se puede reescribir, elimine la palabra clave predeterminada al reescribir
public se puede omitir, el valor predeterminado no se puede omitir
Si se implementan varias interfaces y existe la misma declaración de método en varias interfaces, la subclase debe anular el método
Notas sobre métodos estáticos en interfaces:
1. Los métodos estáticos solo se pueden llamar por nombre de interfaz, no por nombre de clase de implementación o nombre de objeto
2.public se puede omitir, static no se puede omitir
La relación entre clases e interfaces:
La relación entre clase y clase:
Relación de herencia, solo herencia única, pero herencia de múltiples capas
La relación entre clases e interfaces:
La relación de realización se puede implementar en una o varias implementaciones, y se pueden implementar múltiples interfaces en colegas que heredan una clase.
// Si la clase padre y la interfaz tienen la misma declaración de método, la clase padre
La relación entre interfaz e interfaz:
La relación de herencia puede ser de herencia única o herencia múltiple
Polimorfismo:
Pasar parámetros pasar clase padre
La referencia de la clase principal apunta al objeto de la clase secundaria.
El mismo objeto en diferentes formas en diferentes momentos
Ejemplo: gato
Podemos decir que un gato es un gato: gato gato = nuevo gato ();
También podemos decir que los gatos son animales: animal = new cat ();
Los gatos aquí muestran diferentes formas en diferentes momentos, esto es polimorfismo.
La premisa y manifestación del polimorfismo:
Tiene relación de herencia / implementación
Hay formas de reescribir
Tener una referencia de clase principal a un objeto de subclase
ejemplo:
public class Test1Polymorphic {
/*
多态的前提:
1.要有(继承\实现)关系
2.要有方法重写
3.要有父类引用,指向子类对象
*/
public static void main(String[] args) {
//当前事物是一只猫
Cat c = new Cat();
//当前事物是一只动物
Animal a = new Cat();
a.eat();
}
}
class Animal{
public void eat(){
System.out.println("动物吃饭");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
Características del acceso a miembros en polimorfismo:
Método de construcción: al igual que la herencia, la subclase accederá al método de construcción de la clase principal a través de super
Variables miembro: compila y mira a la izquierda (clase principal), ejecuta mira a la izquierda (clase principal)
Método de miembro: compile y mire a la izquierda (clase principal), ejecute y mire a la derecha (clase principal)
public class Test2Polymorphic {
/*
多态成员访问特点:
成员变量:编译看左边(父类),执行看左边(父类)
成员方法:编译看左边(父类),执行看右边(父类)
*/
public static void main(String[] args) {
Fu f =new Zi();
System.out.println(f.num);//10,但必须有父类中的num
f.method();//Zi...method 父类中必须有method()方法
}
}
class Fu{
int num =10;
public void method(){
System.out.println("Fu...method");
}
}
class Zi extends Fu{
int num = 20;
public void method(){
System.out.println("Zi...method");
}
}
¿Por qué el acceso a las variables miembro y a los métodos miembro es diferente?
1. Porque los métodos de miembro se reescriben, pero las variables de miembro no
Las ventajas y desventajas del polimorfismo:
Beneficio: mejorar la escalabilidad del código
Realización específica: al definir un método, utilizando el tipo principal como parámetro, el método puede aceptar cualquier objeto secundario de esta clase principal
Desventajas: no se pueden llamar a funciones específicas de subclase
ejemplo:
public class Test3Polymorphic {
public static void main(String[] args) {
useAnimal(new Dog());
useAnimal(new Cat());
}
public static void useAnimal(Animal a){
a.eat();
}
}
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
Transformación en polimorfismo:
Transformación ascendente: de hijo a padre
Referencias al objeto de clase padre hijo
Transformación descendente: de padre a hijo
Referencia de clase principal al objeto de subclase
ejemplo:
public class Test4Polymorpic {
public static void main(String[] args) {
//1.向上转型:从子到父
// 父类引用指向子类对象
Fu f = new Zi();
f.show();
//多态的弊端 不能调用子类特有的功能
//f.method();
//A.直接创建子类对象
//B.向下转型
//2.向下转型:从父到子
// 父类引用转为子类对象 强制转换
Zi z = (Zi)f;
z.method();
}
}
class Fu{
public void show(){
System.out.println("Fu...show");
}
}
class Zi extends Fu {
@Override
public void show()
{
System.out.println("Zi...show");
}
public void method() {
System.out.println("我是子类特有的方法,method");
}
}
Los riesgos de la transformación en polimorfismo
Si la variable de tipo de referencia convertida, el tipo real correspondiente y el tipo de destino no son del mismo tipo, el nombre aparecerá ClassCastException al convertir
Evite problemas de transferencia forzada
Palabra clave: instanceof
Formato de uso:
Nombre de variable instancia de tipo
Comprensión popular: determine si la variable a la izquierda de la palabra clave es del tipo de la derecha y devuelva el resultado del tipo booleano
ejemplo:
public class Test3Polymorphic {
public static void main(String[] args) {
useAnimal(new Dog());
useAnimal(new Cat());
}
public static void useAnimal(Animal a){
a.eat();
if(a instanceof Dog){
Dog dog = (Dog) a;
dog.watchHome();//ClassCastException类型转换异常
}
// Dog dog = (Dog) a;
// dog.watchHome();//ClassCastException类型转换异常
}
}
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃肉");
}
public void watchHome() {
System.out.println("看门");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}