java笔记二java基础语法

package day02code;
/*面向对象，类与对象，三大特征--封装，构造方法*/
public class Demo01Class {/*什么是类？* 类：一组相关属性和行为的集合，一类事物的模板* 属性：事物的状态信息* 行为：事物能够做什么* 什么是对象？* 对象是类的一个实例，实例一定具备类的属性和行为* 类和对象有什么关系呢？* 类是事物的描述，抽象的。* 对象是事物的实例，具体的。* */
}

package day02code;public class Student {String name;int age;//成员方法的定义就是把之前方法的static给去掉public void study(){System.out.println("我爱学习");}public void eat(){System.out.println("我爱吃饭");}
}

package day02code;public class Test01_Student {/*如何使用定义好的对象呢？* 类名 对象名 = new 类名*/public static void main(String[] args) {Student s = new Student();/*给成员变量赋值*/s.name = "赵四";s.age = 18;/*如何调用成员方法呢？*/s.study();s.eat();}
}

package day02code_package;
/*封装的优化1：this关键字*/
public class Student {/*private 数据类型 变量名*//*提供get方法、set方法，可以访问成员变量* 1.方法就是一个封装* 2.关键字private也是一种封装* this关键字：* this代表所在类的当前对象的引用（地址值），即对象自己的引用* 记住：方法被哪个对象调用，方法中的this就代表哪个对象，即谁在调用，this就代表谁*//*JavaBean* 成员变量* 构造方法* 无参构造方法* 有参构造方法* 成员方法* getXxx()* setXxx()*///成员变量private String name;private int age;//构造方法public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}//成员方法public void setName(String name) {/*this.成员变量名*/this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}

package day02code_package;public class Test01Student {public static void main(String[] args) {//空参构造再赋值Student s = new Student();System.out.println(s);s.setName("柳岩");s.setAge(18);System.out.println(s.getName() + s.getAge());//带参构造Student s2 = new Student("赵丽颖", 19);System.out.println(s2.getName() + s2.getAge());}
}

day07【Scanner类、Random类、ArrayList
类】
Scanner类

package day02ScannerRandomArraylist;import java.util.Scanner;/*什么是API？* Application Programming Interface应用程序编程接口。* JAVA API就是一个字典*/
public class Demo01_Scanner {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int a = sc.nextInt();int b = sc.nextInt();int sum = a + b;System.out.println("sum:" + sum);}
}

Random类

package day02ScannerRandomArraylist;import java.util.Random;
import java.util.Scanner;/*随机产生三个10以内的整数，并输出*/
public class Demo02_Random {public static void main(String[] args) {Random r = new Random();for (int i = 0; i < 3; i++) {int n = r.nextInt(10);System.out.println(n);}/*获取50之间的随机数，包含50*/Random r1 = new Random();int n = 50;int number = r1.nextInt(n) + 1;System.out.println(number);/*猜数字小游戏：* 游戏开始时，会随机生成一个1-100之间的整数number。* 玩家猜测一个数字guessNumber ，会与number作比较，系统提示大了或者小了，* 直到玩家猜中，游戏结束。*/int a = 100;Random r3 = new Random();int Sysnumber = r3.nextInt(a) + 1;while (true) {Scanner sc = new Scanner(System.in);System.out.println("请输入你要猜的数字(1‐100)：");int guessNumber = sc.nextInt();if (guessNumber > number) {System.out.println("你猜的数据" + guessNumber + "大了");} else if (guessNumber < number) {System.out.println("你猜的数据" + guessNumber + "小了");} else {System.out.println("恭喜你,猜中了");break;}}}
}

ArrayList类

package day02ScannerRandomArraylist;import java.util.ArrayList;public class Demo03_ArrayList {/* 什么是ArrayList？* java.util.ArrayList是大小可变的数组的实现，存储在内的数据叫做元素* ArrayList类提供一些方法来操作存储在内部的一些元素，ArrayList中可以不断添加元素，大小也会自动增长* 怎么使用ArrayList呢？* 泛型，表示一种指定的数据类型，Element，出现E的地方，我们使用一种引用数据类型将其替换即可* ，表示我们要存储哪种引用类型的元素* ArrayList,ArrayList*/public static void main(String[] args) {//创建学生数组ArrayList<String> list = new ArrayList<>();//创建学生对象String s1 = "曹操";String s2 = "张飞";String s3 = "关羽";//打印学生ArrayList集合System.out.println(list);//把学生对象作为元素添加到集合中去list.add(s1);list.add(s2);list.add(s3);//再次打印学生集合System.out.println(list);}
}

package day02ScannerRandomArraylist;import java.util.ArrayList;public class Demo04_ArrayListMethod {/*ArrayList是一个类* 那么它包含哪些常用的方法呢？* 对于元素的操作，基本体现在，add，delete，alter，select* public boolean add(E,e):将指定的元素添加到集合的尾部* public E remove(int index):移除此集合中指定位置上的元素.返回被删除的元素。* public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素* public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。*/public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();//add(E,e):将指定的元素添加到集合的尾部list.add("hello");list.add("java");list.add("world");//返回0号索引位置的元素值String str = list.get((0));System.out.println(str);//返回集合中元素的个数int a = list.size();System.out.println(a);//删除指定索引出的元素，返回被删除的元素String str2 = list.remove(1);System.out.println(str2);//遍历ArrayList,首先要知道数组的大小，再去索引对应元素的内容即可for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}}
}

包装类

package day02ScannerRandomArraylist;import java.util.ArrayList;
import java.util.Random;public class Demo05PackageGroup {/*ArrayList对象不能存储基本类型的，只能存储引用类型*也就是说，没有这种情况，那么怎么存储基本数据类型呢？* 包装类型：* 基本类型基本类型包装类byte Byteshort Shortint Integerlong Longfloat Floatdouble Doublechar Characterboolean Boolean*Integer和Character需要特殊记忆，其他的都是把首字母大写即可*/public static void main(String[] args) {/*生成6个1~33之间的随机整数,添加到集合,并遍历*///创建Random对象Random random = new Random();//创建ArrayList对象ArrayList<Integer> list = new ArrayList<>();//添加随机数到集合中去for (int i = 0; i < 6; i++) {int r = random.nextInt(33) + 1;list.add(r);}//遍历集合输出for (int i = 0; i < list.size(); i++) {System.out.print(list.get(i));}}
}

继承

1.先写父类

package day02code_extends;public class Employee {public void method() {System.out.println("方法执行！");}
}

2.再写子类

package day02code_extends;/*先写父类，再写子类extends父类*/
public class Teacher extends Employee {public void printName() {System.out.println("尽心尽力的工作");}
}

3.定义一个测试类

package day02code_extends;
/*在继承的关系中，子类就是一个父类
* 父类是员工
* 子类是讲师*/
public class Demo01Extends {public static void main(String[] args) {Teacher tc = new Teacher();tc.method();/*先写了一个父类，又写了一个子类，不是复杂了么？* 不是，如果是多个子类，只需要写一个父类方法即可*/}
}

如果要是子类的成员变量和父类的成员变量重名了怎么办呢？
super关键字
1.定义父类

package day02code_extends;public class Fu {int num = 5;
}

2.定义子类

package day02code_extends;public class Zi extends Fu {int num = 6;public void show() {System.out.println("Fu num  = " + num);System.out.println("Zi num = " + num);System.out.println("Fu num = " + super.num);System.out.println("Zi num = " + this.num);}
}

3定义测试类

package day02code_extends;public class Demo02Extends {public static void main(String[] args) {Zi z = new Zi();z.show();/*父类的成员变量int num = 5* 子类的成员变量int num = 6* 此时访问的是子类的成员变量num = 6* 如果非要访问父类的非私有成员变量怎么办呢？* super关键字，用法如下*/}
}

4.结果

Fu num  = 6
Zi num = 6
Fu num = 5
Zi num = 6

上面讨论的是成员变量的重名问题，如果方法重名了怎么办呢？
方法的重写，子类会重写和父类同名的构造方法
子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从
而进行扩展增强。
1.定义父类

package day03code_extends;public class Fu {public void show(){System.out.println("我是爸爸");}
}

2.定义子类

package day03code_extends;public class Zi extends Fu {public void show(){System.out.println("我是儿子");}
}

3.定义测试类

package day03code_extends;public class Demo01Test {public static void main(String[] args) {Zi z = new Zi();z.show();}
}

4结果（方法重写的体现）

我是儿子

抽象类：如果每一个子类都去重写父类的成员方法，那么还要父类的成员方法干啥呢？所以抽象类出现了
如何定义一个抽象类？
1.定义父类

package demo01;/*到底是吃鱼还是吃骨头，吃是很抽象的*/
public abstract class Animal {//这是一个抽象方法，代表吃东西，具体吃啥不确定，抽象方法所在的方法一定是抽象类public abstract void eat();
}
//先把抽象方法的void前面加上abstract，再把{}去掉，最后在class前面加上abstract

2.定义子类
对方法进行了重写

package demo01;public class Cat extends Animal {public void eat(){System.out.println("吃鱼");}
}

3.定义测试类

package demo01;public class CatTest {public static void main(String[] args) {Cat c = new Cat();c.eat();}
}
/*1.抽象类不能创建对象，为什么？连方法体都没有
* 2.抽象类的子类，必须重写抽象父类中所有的抽象方法*/

接口就是把一大堆方法放到一起，想实现的时候用一个类去实现就可以了
什么是接口？

package demo02;public interface Demo01Interface {/*什么是接口呢？* 引用类型，方法的集合* 之前学过的类，封装了成员变量，成员方法* 那么，接口的内部就是封装了方法，包含，抽象方法，默认方法，静态方法，私有方法** 创建的时候发现和Class在同一个地方，所以接口和Class是十分相似的，也会被编译成.class文件* 但是Interface是另外一种引用类型* 怎么使用Interface呢？* 搞清楚接口是方法的集合，implements.* 一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法*/
}

接口中可以放入哪些方法呢？

package demo02;public interface InterfaceName {/*定义了一个抽象方法*/public abstract void method1();/*定义了一个默认方法*/public default void method2(){}/*定义了一个静态方法*/public static void method3(){}/*定义了一个私有方法*/private void method4(){}
}

定义一个接口，里面有两个抽象方法

package demo02;public interface LiveAble {public abstract void eat();public abstract void sleep();
}

定义一个Animal测试类去实现接口

package demo02;public class Animal implements LiveAble {@Overridepublic void eat() {System.out.println("吃东西");}@Overridepublic void sleep() {System.out.println("晚上睡");}
}

第三大特性，多态，多态有两种体现方式，一种是通过子父类去实现，另一种是用接口去实现，这里用的是子父类去实现
1.定义一个父类

package demo05;public abstract class Animal {public abstract void eat();
}

2.定义猫狗两个子类

package demo05;public class Cat extends Animal {public void eat(){System.out.println("吃鱼");}
}

package demo05;public class Dog extends Animal {public void eat(){System.out.println("吃骨头");}
}

3.实现多态

package demo05;public class Test {/*多态的体现* 父类类型 变量名 = new 子类对象* 变量名.方法名（）* 什么是父类类型呢？* 继承的角度：子类继承父类对象* 实现的角度：类实现父接口类型*/public static void main(String[] args) {//从继承的角度去创建对象//父父new子Animal a1 = new Cat();//看到方法想到 调用 两个字，此处调用的是Cat的eat方法//子类和父类想到 继承 两个字//接口想到 实现 两个字a1.eat();Animal a2 = new Dog();//调用的是Dog中的eata2.eat();}
}

4.多态的好处

package demo06;public class Test01 {public static void main(String[] args) {Animal c = new Cat();Dog d = new Dog();
//        showCatEat(c);showDogEat(d);showAnimalEat(c);showAnimalEat(d);}/*不用多态的话要写两个方法才行*/public static void showCatEat(Cat c) {c.eat();}public static void showDogEat(Dog d) {d.eat();}/*用多态的话写一个方法就可以了*/public static void showAnimalEat(Animal a) {a.eat();}}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！