类和对象
-
类是对一类事物的描述，是抽象的。
-
对象是一类事物的实例，是具体的。
-
类是对象的模板，对象是类的实体。
【修饰符】 class 类名{
}
new 类名()//也称为匿名对象
类名 对象名 = new 类名();
public static void main(String[] args) {
People p = new People();
p.name = "张三";
p.age = 18;
p.sex = "男";
Cat cat = new Cat();
cat.name = "小花";
cat.age = 2;
cat.color = "白色";
cat.likes = new String[]{"吃鱼","吃猫粮"}
p.cat = cat;
System.out.println(p.name);
System.out.println(p.age);
System.out.println(p.sex);
System.out.println(p.cat.color);
System.out.println(p.cat.name);
System.out.println(p.cat.age);
System.out.println(Arrays.toString(p.cat.likes));
}
public class People {
String name;
String sex;
int age;
Cat cat;
}public class Cat {
String color;
int age;
String name;
String [] likes;
}成员变量
【修饰符】 class 类名{
【修饰符】 数据类型 成员变量名;
}
public class Person{
String name;
char gender;
int age;
}必须在类中，方法外
实例变量的值是属于某个对象的
必须通过对象才能访问实例变量
每个对象的实例变量的值是独立的
实例变量的访问
对象.实例变量
方法
（1）必须先声明后使用
类，变量，方法等都要先声明后使用
（2）不调用不执行，调用一次执行一次。
方法：参数 、 返回值 、 方法体
public static void main(String[] args) {
// 方法：参数 、 返回值 、 方法体
/*
1. 无参无返回
2. 无参有返回 √
3. 有参无返回
4. 有参有返回 √
无参有返回
修饰符 返回值类型 方法名(参数列表) {
// 方法体
}
对象.方法名(); // 无返回
变量类型 变量名 = 对象.方法名(); // 有返回
*/
// 无参有返回
// 创建对象
GameUtils gameUtils = new GameUtils();
// void没有返回值
// 方法必须调用才会执行
gameUtils.game();
gameUtils.game();
// String result = gameUtils.game();
// System.out.println(gameUtils.game());
// 调用方法
System.out.println(gameUtils.randomGame());
gameUtils.test("测试123");
}public static void main(String[] args) {
// 实参和形参
GameUtils gameUtils = new GameUtils();
gameUtils.test("看见方法1.返回值2.参数");
gameUtils.test2(1,2);
gameUtils.test3("hello",2,5);
gameUtils.test4(new int[] {1,23,4});
int [] numbers = {1,2,3,4,5};
gameUtils.test4(numbers);
// gameUtils.test4(4,3,2); // 错误3个参数
gameUtils.test5(); // 0 参数
gameUtils.test5(1);// 1参数
gameUtils.test5(1,2,3,4,5,6,7,8,9,10);
gameUtils.test6(100);
gameUtils.test6(100,23);
gameUtils.test6(100,numbers);
gameUtils.test7("张三","李四");
gameUtils.test7(new String[] {"张三","李四"});
gameUtils.test8();
gameUtils.test8(new Dog(),new Dog());
}public class GameUtils {
// 1.无参有返回
public String randomGame(){
String [] games = {"剪刀","石头","布"};
return games[(int)(Math.random() * 3)];
}
// 2.无参无返回
public void game(){
System.out.println("开始游戏！！！");
}
// 3.有参无返回
public void test(String string){
System.out.println(string.length());
}
// 多参数问题
public void test2(int number1 ,int number2){
System.out.println(number1 + number2);
}
public void test3(String string1 , int number1 , int number2){
System.out.println(string1 +( number1 + number2));
}
// 参数直接是数组
public void test4(int [] numbers){
System.out.println(Arrays.toString(numbers));
}
// 多参数！！！
public void test5(int ... numbers){
System.out.println(Arrays.toString(numbers));
}
// 报错
// public void test6(int ... numbers,int number2){
//
// }
// 100,23
public void test6(int number1 ,int ... numbers){
System.out.println(number1 + Arrays.toString(numbers));
}
// public void test7(int ... numbers,String name){
// System.out.println(Arrays.toString(numbers) + name);
// }
public void test7(String ... names){
System.out.println(Arrays.toString(names));
}
public void test8(Dog ... dogs){
System.out.println(Arrays.toString(dogs));
}实例变量与局部变量的区别
1、声明位置和方式
（1）实例变量：在类中方法外
（2）局部变量：在方法体{}中或方法的形参列表、代码块中
2、在内存中存储的位置不同
（1）实例变量：堆
（2）局部变量：栈
3、作用域
（1）实例变量：通过对象就可以使用，本类中“this.，没有歧义还可以省略this.”，其他类中“对象.” （2）局部变量：出了作用域就不能使用
封装
-
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
-
低耦合：仅对外暴露少量的方法用于使用
隐藏对象内部的复杂性，只对外公开简单和可控的访问方式，从而提高系统的可扩展性、可维护性。
公开的方法,可以直接调用
成员变量私有化之后,用set()/get()方法去使用和获取
使用 private 修饰成员变量
-
private 数据类型 变量名 ；
-
提供
getXxx方法 /setXxx方法，可以访问成员变量
public static void main(String[] args) {
// private 默认的 protected public
Dog dog = new Dog();
dog.setAge(12);
dog.setColor("yellow");
System.out.println(dog);
System.out.println(dog.getAge());
System.out.println(dog.getColor());
}public class Dog {
// 封装
// 属性私有化
private int age;
private String color;
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
public void setColor(String color){
this.color = color;
}
public String getColor(){
return this.color;
}
public String toString() {
return "Dog [age=" + age + ", color=" + color + "]";
}
}
继承
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成某种关系.
【修饰符】 class 父类 {
...
}
【修饰符】 class 子类 extends 父类 {
...
}
子类可以重写父类的方法
public static void main(String[] args) {
Animal animal=new Animal();
animal.age=12;
animal.setName("小白");
animal.setColor("白色");
animal.eat();
System.out.println(animal);
Dog dog=new Dog();
dog.age=12;
dog.setName("大黄");
dog.setColor("黄色");
dog.eat();
System.out.println(dog);
}public class Animal {
public int age;
private String name;
private String color;
public void eat(){
System.out.println(this.name+"动物吃东西");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Animal{" +
"age=" + age +
", name='" + name + '\'' +
", color='" + color + '\'' +
'}';
}
}public class Dog extends Animal{
@Override
public void eat() {
System.out.println(getName()+"吃骨头");
super.eat();
}
}多态
编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法；
运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；
public static void main(String[] args) {
Animal animal=new Dog();
animal.setName("大黄");
animal.setAge(6);
animal.eat();
Dog dog=(Dog) animal;
dog.lookHouse();
System.out.println(animal);
//向上转型：自动完成
Animal animal1=new Cat();
animal1.setName("大白");
//向下转型：（子类类型）父类变量
Cat cat=(Cat)animal1;
cat.catchMouse();
System.out.println(animal1);
System.out.println("----------------------");
Person p =new Person();
p.setName("张三");
Dog dog1=new Dog();
dog1.setName("大黄");
p.feed(dog1);
Cat cat1=new Cat();
cat1.setName("大白");
p.feed(cat1);
System.out.println("-----------------------");
}Person类
public class Person {
private String name;
private Integer age;
public void feed(Animal animal){
System.out.println(this.name+"喂养"+animal.getName());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}父类 Animal
public class Animal {
private int age;
private String name;
public void eat(){
System.out.println(name+"动物吃东西");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Animal{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}子类 Dog
public class Dog extends Animal{
@Override
public void eat() {
System.out.println(getName()+"吃骨头");
}
public void lookHouse(){
System.out.println(getName()+"看家");
}
}子类 Cat
public class Cat extends Animal{
@Override
public void eat() {
System.out.println(getName()+"吃猫粮");
}
public void catchMouse(){
System.out.println(getName()+"抓老鼠");
}
}构造器
【修饰符】 class 类名{
【修饰符】 构造器名(){
// 实例初始化代码
}
【修饰符】 构造器名(参数列表){
// 实例初始化代码
}
}
必须要有无参构造器
没有构造器时IDE会默认生成一个无参构造器
public class People {
private String name;
private Integer age;
public People(String name, Integer age) {
this.name = name;
this.age = age;
}
public People() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}猫狗与生成一个动物的构造器(首先动物得有)
public static void main(String[] args) {
People people =new People("小明",12);
System.out.println(people);
Animal[] animal=new Animal[2];
animal[0]=new Dog(12,"大白");
animal[1]=new Cat(6,"小白");
System.out.println(Arrays.toString(animal));
}非静态代码和静态代码块
静态方法和实例方法区别
1.
调用方法不一样
静态方法：类名.方法
实例方法：对象.方法
2.
静态方法和实例方法区别
在静态方法是无法使用获取实例的属性和方法
在实例方法中可以获取实例的属性和方法
3.
静态代码块在类初始化时执行，只执行一次
非静态代码块在实例初始化时执行，每次new对象都会执行
public static void main(String[] args) {
System.out.println("实例方法：非静态方法--------------------------");
NumberUtils numberUtils = new NumberUtils();
int result = numberUtils.sum(1,2);
System.out.println(result);
System.out.println("静态方法-----类名.方法----------------------");
int result2 = NumberUtils.sum2(1,2);
System.out.println(result2);
System.out.println(numberUtils.sum2(2,3)); // 静态方法可以对象.方法名
}public static void main(String[] args) {
NumberUtils numberUtils = new NumberUtils();
numberUtils.setCount(120);
System.out.println(numberUtils.sum(2,3));
System.out.println("-----------------------------------");
System.out.println(NumberUtils.sum2(2,3));;
}public class NumberUtils {
private int count;
public final int number1 = 10;
public static int number2 = 20;
// 静态代码块
static {
System.out.println("NumberUtils static---------------------");
}
public int sum(int number1 ,int number2){
System.out.println("sum:" + count);
return number1 + number2;
}
public static int sum2(int number1 ,int number2){
// System.out.println("sum2:" + count);
return number1 + number2;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}// 实例变量直接初始化 < 非静态代码块 < 构造方法
枚举
enum关键字声明枚举
【修饰符】 enum 枚举类名{
常量对象列表
}
【修饰符】 enum 枚举类名{
常量对象列表;
其他成员列表;
}
限定一个范围,只能从限定得范围里面拿值
public static void main(String[] args) {
Sex sex = Sex.WOMAN;
System.out.println(sex);
People people = new People();
people.setAge(12);
people.setName("张三");
people.setSex(Sex.MAN);
System.out.println(people);
}public enum Sex {
// 分号可以省略不写
MAN,WOMAN
}public class People {
private int age;
private String name;
private Sex sex;
public People() {
}
public People(int age, String name, Sex sex) {
this.age = age;
this.name = name;
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Sex getSex() {
return sex;
}
public void setSex(Sex sex) {
this.sex = sex;
}
@Override
public String toString() {
return "People{" +
"age=" + age +
", name='" + name + '\'' +
", sex=" + sex +
'}';
}
}星期案例
- String name():返回的是常量名（对象名）
- int ordinal():返回常量的次序号，默认从0开始
- 枚举类型[] values():返回该枚举类的所有的常量对象，返回类型是当前枚举的数组类型，是一个静态方法
- 枚举类型 valueOf(String name)：根据枚举常量对象名称获取枚举对象
- Week week =Week.MONDAY
- 类名 对象名 =类名.常量
public enum Week {
MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),
THURSDAY("星期四"),FRIDAY("星期五"),SATURDAY("星期六"),
SUNDAY("星期日");
private String week;
Week(String week){
this.week = week;
}
public String getWeek() {
return week;
}
public void setWeek(String week) {
this.week = week;
}
@Override
public String toString() {
return week;
}
}public static void main(String[] args) {
Week week = Week.TUESDAY;
System.out.println(week);
switch (week){
case MONDAY:
case TUESDAY:
case WEDNESDAY:
case THURSDAY:
case FRIDAY:
System.out.println("工作日：！！！");
break;
case SATURDAY:
case SUNDAY:
System.out.println("休息日：！！！");
break;
}
System.out.println(week.name());
System.out.println(week.getWeek());
System.out.println(week.ordinal());
Week [] weeks = Week.values();
System.out.println("----------------------");
System.out.println(Arrays.toString(weeks));
for (Week week1 : weeks){
System.out.println("" + week1 + (week1.ordinal()+1));
}
Week week1 = Week.valueOf("TUESDAY");
System.out.println(week1);
Sex2 sex2 = Sex2.valueOf("MAN");
System.out.println(sex2);
}抽象
-
抽象方法：被abstract修饰没有方法体的方法。
-
抽象类：被abstract修饰的类。
【权限修饰符】 abstract class 类名{
}
【权限修饰符】 abstract class 类名 extends 父类{
}
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类
public static void main(String[] args) {
m4();
}
public static void m4(){
// 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类
TestD testD = new TestD();
testD.testB1();
testD.testB2();
testD.testC1();
}
public static void m3(){
// 抽象类不一定要有抽象方法
// 匿名类
TestA testA = new TestA(){
};
System.out.println(testA);
}
}重写类中没有写完得方法
B留了两个遗愿
public abstract class TestB {
public abstract void testB1();
public abstract void testB2();
}C完成1个,并且留下了一个
public abstract class TestC extends TestB{
public abstract void testC1();
public void testB1() {
System.out.println("TestC.testB1");
}
}D完成了C的和B的
public class TestD extends TestC{
@Override
public void testB2() {
System.out.println("TestD.testB2");
}
@Override
public void testC1() {
System.out.println("TestD.testC1");
}
}接口
接口不能创建对象，但是可以被类实现（implements ，类似于被继承）。
接口里面默认都是抽象方法
公共的静态的常量：其中public static final可以省略
公共的抽象的方法：其中public abstract可以省略
public static void main(String[] args) {
ClassA classA = new ClassA();
classA.test1();
classA.test2();
classA.test3();
m1(classA);
m2(classA);
m3(classA);
}
public static void m3(Interface3 interface3){
System.out.println(interface3.getClass().getName());
}
public static void m2(Interface2 interface2){
System.out.println(interface2.getClass().getName());
}
// 当一个类实现了对应接口，就能把对象传递过去
public static void m1(Interface1 interface1) {
System.out.println(interface1.getClass().getName());
}public interface Interface1 {
public void test1();
}public interface Interface2 {
public void test2();
}public interface Interface3 {
public void test3();
}public class ClassA implements Interface1 , Interface2 , Interface3{
@Override
public void test1() {
}
@Override
public void test2() {
}
@Override
public void test3() {
}
}
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
