java面向对象，继承，多态，常用类，集合，字符串前后输出

最新推荐文章于 2024-06-07 08:25:31 发布

幼儿园技术

最新推荐文章于 2024-06-07 08:25:31 发布

阅读量529

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/ilanyangyang/article/details/121517273

版权

java面向对象

类和对象

类：相同特征和行为的集合，可以嵌套
对象：对象是一个具体的概念
new一个对象之后就相当于开辟了一个新的堆内存（右边的）空间
左边的是栈内存

类的封装

作用：隐藏实现细节
怎么封装？？成员变量私有化，公开的set，get方法

private String name;
private int age;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
if(age<=0){
Syste....错误
}
else{
this.age=age;
}
}
public int getAge(){
return age;
}

方法的重载和递归

重载的方法名一样，参数的类型或个数不同，与返回值无关
重写也叫覆盖
方法的递归
求1~n的和

public class Aaa{
public static int getSum(int n){
if(n==1)
{return 1;}
int temp=getSum(n-1);
return temp+n;
}
public static void main(String[] args){
int sum=getSum(4);
Sys....sum;
}
}

重载与覆盖（重写）的区别

重载是在一个类中，是水平关系。覆盖是子类和父类的关系，是垂直关系

构造方法

方法与类名相同
没有返回值类型的声明
方法中不能使用return语句返回一个值，可以单独写return语句来作为方法的结束
如果存在有参的构造方法，则系统不在提供无参的构造方法
为了方便，一般使用public修饰
构造方法调用Person person=new Person(参数1，参数2...)
子类不能继承父类的构造方法（只是被子类调用了）

public class A{
public A(){
Sys...调用了无参的构造方法
}
}

构造方法的重载

public class Student {
String name;
int grade;
public Student() {}
public Student(String n,int g) {
	name=a;
	grade=g;
}
public void say(){
Sys...age
}
}
public B{
public static void main(String[] args){
int age;
String name;
Student s1=new Student();
Student s1=new Student("ad",15);
s2.say();
}
}
输出15

this关键字

用于在方法中访问对象的其他成员
只能在构造方法中使用this调用其他的构造方法，不能再成员方法中使用。使用时，必须是第一条语句，并且只能出现一次。不能在一个类中的两个构造方法中互相使用this调用

class Animal{
	public Animal(){
		this(12);//调用了有参的构造方法
		System.out.println("wucan");
		}
		public Animal(int age){
		
		System.out.println("youcan");
		}
}
class bbb{
	public static void main(String[] args){
		Animal dog = new Animal();//此时在内存中存在两份name数据
	}
}
输出：
youcan
wucan

class Animal{
	String name;	//成员变量
	String color;
	public Animal(String n,String c){
		name = n;
		color = c;
	}
	public void eat(){
		String name = "老鼠";	//局部变量
		System.out.println(this.name+"在吃……");
		//猫在吃
		System.out.println(name+"在吃……");
		//老鼠在吃
	}
}
 
class bbb{
	public static void main(String[] args){
		Animal dog = new Animal("狗","白色");//此时在内存中存在两份name数据
		Animal cat = new Animal("猫","黑色");
		cat.eat();
	}
}

static关键字

希望某些特定的数据在内存中只有一份，并且能够背一个类的所有实例对象所共享类成员（静态成员）属于这个类而不是属于这个类的某个对象，它由这个类所创建的所有对象共同拥有。
静态变量的访问：类名.变量名
static只能修饰成员变量，不能修饰局部变量，可以被继承，不可以被重写
定义常量：public static final String CLOOAGE=“DFDF”;

class Person {
    static String a;
}
    public class bbb{
    	 public static void main(String[] agrs) {
    	    	Person p=new Person();
    	    	Person p1=new Person();
    	    	Person.a="dfdf";
    	    	System.out.println(p.a);
    	    	System.out.println(p1.a);
    	    }
    }
    输出
    dfdf
    dfdf

静态方法的访问：类名.方法名，，，，实例对象名.方法名

什么时候可以把方法变为静态，方法的结果跟具体的对象无关
静态方法可以直接调用同类中的静态成员，但不能直接调用非静态成员， 如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量
在普通成员方法中，则可以直接访问同类的非静态变量和静态变量
修饰完的方法可以被继承，不可以被重写
静态代码块
只在编译的时候执行

构造方法的调用在同一个类中

class Person {
    private String name;
    private int age;
    //构造方法一
    public Person() {
        this("asdf");
    }
    //构造方法二
    public Person(String n) {
        this(n, 12);//调用第三个
        System.out.println(n);
    }
    //构造方法三
    public Person(String n, int a) {
        this.name = n;
        this.age = a;
        System.out.println(n+12);
    }
}
    public class bbb{
    	 public static void main(String[] agrs) {
    	    	Person p=new Person();
    	    }
    }

方法的三要素：方法名，参数，返回值的类型（由返回值决定）

干什么：修饰类的成员，共享给所有对象
作用：

类的继承，子类无论如何都会继承父类中的无参构造方法，有参的要用super

继承的时候，子类会自动继承父类中公共的方法，不需要在子类中写出该方法
单继承，不能继承多个，构造方法不能继承
私有的成员变量也能继承，要通过set，get方法继承
显示继承：所有非私有操作属于显示继承（可以直接调用）。
隐式继承：所有私有操作属于隐式继承（不可以直接调用，需要通过其它形式调用（get或者set））。

重写

三要素要和父类相同（方法名，参数，返回值类型）
重写父类的方法时，访问权限要大于等于父类
不能抛出比父类更多的异常
只有public和protect可以重写
static final private 都不可以重写

final关键字

final修饰的类不能被继承，但是修饰的方法能被继承
修饰的方法 不能被子类重写
修饰的变量（成员变量和局部变量）是常量，只能赋值一次（不能修改）

class Person {
    static String a;
    int b;
    String name;
    private int age;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void printa() {
		// TODO Auto-generated method stub
		System.out.println("动物叫声");
	}
	public void printb() {
		// TODO Auto-generated method stub
		System.out.println("自动继承了父类，如果不对方法进行修改不需要在子类中重写方法");
	}
	public final void printc() {
		// TODO Auto-generated method stub
		System.out.println("final修饰的方法能被继承,但不能被子类重写");
	}
}
class A extends Person{
	public void printa() {
		System.out.println("汪汪汪......");
		System.out.println("name="+name);
		System.out.println("age="+getAge());
	}
}
    public class bbb{
    	 public static void main(String[] agrs) {
    	    	Person p=new Person();
    	    	Person p1=new Person();
    	    	Person.a="dfdf";
    	    	//p1.name="子类 能不能直接访问父类被重写的方法";
    	    	Person a=new A();
    	    	a.name="zzzb";
    	    	a.setAge(154);
    	    	a.printa();
汪汪汪......
name=zzzb
age=154
    	    	a.printb();
自动继承了父类，如果不对方法进行修改不需要在子类中重写方法
    	    	A a1=new A();
    	    	a1.printa();
汪汪汪......
name=null
age=0
    	    	a1.printc();
final修饰的方法能被继承,但不能被子类重写
    	    	System.out.println(p.a);
    	    	System.out.println(p1.a);
    	    }
    }
    输出
汪汪汪......
name=zzzb
age=154
自动继承了父类，如果不对方法进行修改不需要在子类中重写方法
汪汪汪......
name=null
age=0
final修饰的方法能被继承,但不能被子类重写
dfdf
dfdf

super关键字的使用，调用父类的构造方法等

解决子类对象无法直接访问父类被重写的方法（不能输出父类中方法的东西了，super关键字调用之后就可以输出）
子类中调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次

class Person {
    static String a;
    int b;
    String name;
    String asd="super";
	public void printa() {
		// TODO Auto-generated method stub
		System.out.println("动物叫声");
	}
	public Person(String canshu) {
		System.out.println("参数是"+canshu);
	}
}
class A extends Person{
public A() {
		super("沙皮狗");
		// TODO Auto-generated constructor stub
	}
	public void printa() {
		String name="张智保";
		System.out.println("汪汪汪......");
		System.out.println("name="+name);
		System.out.println("name="+super.name);
		System.out.println("asd="+super.asd);
		System.out.println("age="+getAge());
		System.out.println(a);
		super.printa();
	}
}
    public class bbb{
    	 public static void main(String[] agrs) {
    	    	A a1=new A();
    	    	a1.printa();
参数是沙皮狗      super关键字调用父类的构造方法
汪汪汪......
name=张智保
name=null       在测试方法中设置变量，不能够通过super关键字实现效果
asd=super
age=0
dfdf
动物叫声 	
Person p=new Person();
    	    	Person p1=new Person();
    	    	Person.a="dfdf";
    	    	Person a=new A();
    	    	a.name="zzzb";
    	    	a.setAge(154);
    	    	a.printa();
汪汪汪......
name=张智保
name=zzzb
asd=super
age=154
dfdf     static关键字修饰的变量也可以继承
动物叫声
    	    }
    }

抽象类

抽象类中可以没有抽象方法，抽象方法一定有抽象类
抽象类是被用于继承的，不能用final修饰
抽象方法没有方法体，所以抽象类不可以被实例化，抽象方法也不可以被调用

[修饰符] abstract class Person1{
	public abstract void shout();
}
class A1 extends Person1{
	@Override
	public void shout() {
		// TODO Auto-generated method stub
		System.out.println("afdf");
	}
}
public class aa {
	public static void main(String args[]) {
		A1 a=new A1();
		a.shout();
	}
	}

接口，，，，，，

接口是一种特殊的抽象类，不包含普通方法，全是抽象方法abstract，1.8之后，可以有默认方法和静态方法，
接口不能被实例化，因为没有方法体，不能有构造方法
使用interface关键字修饰
[]的内容是可选的，多继承的是父接口

[修饰符] interface 接口名 [extends 父接口1，父接口2...]{
[public] [static] [final] 常量类型 常量名 = 常量值;
[public] [abstract] 方法返回值类型 方法名([参数列表]);
[public] static 方法返回值类型 方法名([参数列表]){
}
[public] default 方法返回值类型 方法名([参数列表]){
}
[修饰符] class 类名 [extends 父类名] [implements 接口1，接口2，...] {
}
}

包

必须在所有代码前声明
定义包：package 包名；
导入包：import 包名.类名

java.util 工具类，集合类。例如Arrays，List，Set
java.net java网络相关的类和接口
java.io java输入，输出相关的类和接口
java.awt GUI

java常用类

一个异常将终止产生异常的try快
catch可以有多个也可以没有，finally可以没有
finally是异常处理的出口
异常是个对象
异常的所有父类是Throwable
set集合特点元素无序且不可重复
set集合如何处理重复元素
如果加入一个重复元素add方法将返回false
list特点元素有序可重复

        System.out.println(Math.ceil(4.6));//向上取整，5.0
		System.out.print(Math.floor(4.6));//向下取整，4.0
		System.out.println(Math.round(4.6));//四舍五入，5

java基础语法

java的字符采用的是Unicode编码每个占用16个比特位
char在java中称为“字符型” 占2个字节
字符常量是用单引号括起的一个字符且字符常量在内存中存储的是该字符在Unicode字符集中的排序位置，即整数
eg：char x=‘a’，不能是char x=‘abc’
ASCII码值，A=65,a=97

在字符串前是正常的加法运算，字符串之后变成字符串相加，字符串之后如果是带有括号的，也是正常运算
5. 在这里插入图片描述

面向对象习题

当一个父类成员不适合该子类时，子类会以恰当的方式重新定义它。（T）
1. 在运行时才确定调用那一个方法，这叫做动态绑定。

方法的重载

名称相同，参数的类型或个数不同的方法
与返回值无关

package包

有的类可以不包含package语句

要把类放到某个包需要用package语句，事实上，当我们没有使用package语句时，我们的类都被放到了一个默认缺省包，这也是为什么我们运行Java程序时，在运行目录下面不能有同名的.class文件。

java继承

如果要实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化，即：默认情况下，子类会找到父类之中的无参构造方法。
this关键字默认调用的是自己类中的无参构造方法

public class Pet{
private String name;
public Pet(){
System.out.print(1);
   }
public Pet(String name){
System.out.print(2);
   }
}
public class Dog extends Pet{
public Dog(){
System.out.print(4);
   }
public Dog(String name){
this();
System.out.print(3);
   }
}
执行new Dog(“棕熊”);后程序输出是哪项？A
A. 143
B. 423
C. 243
D. 1134

抽象类

抽象类可以有构造方法
抽象类可以没有抽象方法，但是有抽象方法的一定是抽象类

幼儿园技术

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java面向对象，继承，多态，常用类，集合，字符串前后输出

java常用类一个异常将终止产生异常的try快catch可以有多个也可以没有，finally可以没有异常是个对象异常的所有父类是Throwableset集合特点元素无序且不可重复 list特点元素有序可重复java基础语法java的字符采用的是Unicode编码每个占用16个比特位char在java中称为“字符型” 占2个字节字符常量是用单引号括起的一个字符且字符常量在内存中存储的是该字符在Unicode字符集中的排序位置，即整数eg：char x=‘a’...
复制链接

扫一扫