Day1 面向对象基础
this
当局部变量和全局变量的数据类型和名称都相同时,Java规定可以使用this关键字去访问全局变量
this语法格式:
this.成员变量名
this.成员方法名()
this就是一个变量,可以用在方法中,来拿到当前对象
用于解决变量名称冲突问题
package com.itheima.object.thisdemo;
public class Student {
double score;
public void printThis(){
System.out.println(this);
}
public void printPass(double score){
if(this.score > score){
System.out.println("恭喜您,您成功考入了东北林业大学");
}else{
System.out.println("落选了");
}
}
}
package com.itheima.object.thisdemo;
public class Test {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1);
s1.printThis();
Student s2 = new Student();
System.out.println(s2);
s2.printThis();
Student s3 = new Student();
s3.score = 365;
s3.printPass(280);
}
}
构造器
无参构造器
public Student(){
}
有参构造器
public Student(String name,double score){
}
特点:创建对象时,对象会去调用构造器
Student s = new Student();
package com.itheima.constructor;
public class Student {
String name;
double score;
//无参数构造器
public Student(){
System.out.println("无参数构造器被触发执行了");
}
//有参数构造器
public Student(String name,double score){
System.out.println("有参数构造器被触发执行了");
this.name=name;
this.score=score;
}
}
package com.itheima.constructor;
public class Test {
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student("波仔",99);
System.out.println(s2.name);
System.out.println(s2.score);
}
}
类在设计时,如果不写构造器,Java会为类自动生成一个无参构造器
一旦定义了有参构造器,Java就不会帮我们的类自动生成无参构造器了,此时就建议自己手写一个无参数构造器出来
面向对象三大特征:封装、继承、多态
封装
封装的设计规范
成员变量隐藏起来,设置合适的get、set方法暴露给外界访问
实体类
-
要求这个类中的成员变量都要私有,并且要对外提供相应的get、set方法
-
类中必须要有一个公共的无参构造器
package com.itheima.javabean;
public class Student {
//1.实体类必须私有成员变量,并为每个成员变量提供get set方法
private String name;
private double score;
//2.必须为类提供公开的无参构造器
public Student(String name, double score) {
this.name = name;
this.score = score;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
}
自动生成get、set方法
按住shift键全选
自动生成无参构造器
自动生成有参构造器
包
-
同一个包下的程序,可以直接访问
-
访问其他剥下的程序,必须导包才可以访问
-
自己的程序中调用Java提供的程序,也需要先导包才可以使用;注意:Java.lang包下的程序是不需要我们导包的,可以直接使用
-
访问多个其他包下的程序,这些程序名又一样的情况下,默认只能导入一个程序,另一个程序必须带包名和类名来访问
String
package com.itheima.String;
public class StringDemo1 {
public static void main(String[] args) {
String s = "黑马Java";
//1.获取字符串的长度
System.out.println(s.length());
//2.提取字符串中某个索引位置处的字符
char c = s.charAt(1);
System.out.println(c);
//3.把字符串转换成字符数组,再进行遍历
char[] chars = s.toCharArray();
for(int i = 0;i < chars.length; i++){
System.out.println(chars[i]);
}
//4.判断字符串内容,内容一样就返回true
String s1 = new String("黑马");
String s2 = new String("黑马");
System.out.println(s1==s2);//false 判断的是地址
System.out.println(s1.equals(s2));//true
//5.忽略大小写比较字符串内容,常用于验证码
String c1 = "34AeFG";
String c2 = "34aEfg";
System.out.println(c1.equals(c2));//false
System.out.println(c1.equalsIgnoreCase(c2));//true
//6.截取字符串内容(包前不包后)
String s3 = "Java是最好的编程语言之一";
String rs = s3.substring(0,8);
System.out.println(rs);
//7.从当前索引位置一直截取到字符串末尾
String rs2 = s3.substring(5);
System.out.println(rs2);
//8.把字符串中的某个内容替换成新内容,并返回新的字符串对象给我们--用于替换敏感词
String info = "这个电影简直是个垃圾";
String rs3 = info.replace("垃圾","**");
System.out.println(rs3);
//9.判断字符串中是否包含某个关键字
String info2 = "Java是最好的编程语言之一";
System.out.println(info2.contains("Java"));//true
//10.判断字符串是否以某个字符串开头
String rs4 = "张三丰";
System.out.println(rs4.startsWith("张"));//true
System.out.println(rs4.startsWith("张三"));//true
//11.把字符串按照某个指定内容分割成多个字符串,放到一个字符串数组中返回给我们
String rs5 = "张无忌,周芷若,殷素素,赵敏";
String[] names = rs5.split(",");
for(int i = 0 ;i <names.length;i++){
System.out.println(names[i]);
}
}
}
String案例 —— 用户登录
package com.itheima.String;
import java.util.Scanner;
public class StringTest {
public static void main(String[] args) {
for(int i=0;i<3;i++) {
//1.开发一个登录界面
Scanner sc = new Scanner(System.in);
System.out.println("请您输入登录名称:");
String loginName = sc.next();
System.out.println("请您输入登录密码:");
String passWord = sc.next();
//5.开始调用登录方法,判断是否登陆成功
boolean rs = login(loginName, passWord);
if (rs) {
System.out.println("恭喜您,欢迎进入系统~~");
break;
} else {
System.out.println("登录名或者密码错误,请您确认~~");
}
}
}
//2.开发一个登录方法,接收用户的登录名和密码,返回认证的结果
public static boolean login(String loginName,String passWord){
//3.准备一份系统正确的登录名和密码
String okLoginName = "itheima";
String okPassWord = "123456";
//4.开始正式判断用户是否登录成功
if(okLoginName.equals(loginName)&&okPassWord.equals(passWord)){
return true;
}else{
return false;
}
}
}
String案例 —— 验证码
package com.itheima.String;
import java.util.Random;
public class StringTest2 {
public static void main(String[] args) {
System.out.println(createCode(4));
}
//1.设计一个方法,返回指定位数的验证码
public static String createCode(int n){
//2.定义2个变量 一个是记住最终产生的随机验证码;一个是记住可能用到的全部字符
String code ="";
String data="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
Random r = new Random();
//3.开始定义一个循环产生每位随机字符
for(int i = 0;i<n;i++){
//4.随机一个字符范围内的索引
int index = r.nextInt(data.length());
//5.根据索引去全部字符中提取该字符
code += data.charAt(index);
}
return code;
}
}
ArrayList
什么是集合:一种容器,用来存储数据
集合显著特点:集合大小可变
package com.itheima.arraylist;
import java.util.ArrayList;
public class ArrayListDemo {
public static void main(String[] args) {
//1.创建一个ArrayList的集合对象
ArrayList list = new ArrayList();
list.add("黑马");
list.add(666);
list.add(99.5);
list.add("黑马");
list.add("Java");
System.out.println(list);
ArrayList<String>list2 = new ArrayList<String>();
list2.add("黑马");
list2.add("黑马");
list2.add("Java");
System.out.println(list2);
//2.往集合中某个索引位置处添加一个数据
list.add(1,"MySQL");
System.out.println(list);
//3.根据索引获取集合中某个索引位置处的值
String rs = list2.get(1);
System.out.println(rs);
//4.获取集合的大小(返回集合中存储的元素个数
System.out.println(list2.size());
//5.根据索引删除集合中的某个元素值,会返回被删除的元素值给我们
System.out.println(list.remove(1));
System.out.println(list);
//6.直接删除某个元素值,删除成功会返回true,反之
System.out.println(list.remove("Java"));
System.out.println(list);
//默认删除的是第一次出现的黑马数据
System.out.println(list.remove("黑马"));
System.out.println(list);
//7.修改某个索引位置处的数据,修改后会返回原来的值给我们
System.out.println(list.set(1,"黑马程序员"));
System.out.println(list);
}
}
ArrayList应用案例
package com.itheima.arraylist;
import java.util.ArrayList;
public class ArrayListTest {
public static void main(String[] args) {
//1.创建一个ArrayList集合对象
ArrayList<String> list = new ArrayList<String>();
list.add("Java入门");
list.add("宁夏枸杞");
list.add("黑枸杞");
list.add("人字拖");
list.add("特级枸杞");
list.add("枸杞子");
System.out.println(list);
//[Java入门, 宁夏枸杞, 黑枸杞, 人字拖, 特级枸杞, 枸杞子]
//[Java入门, 黑枸杞, 人字拖, 枸杞子]
//2.开始完成需求:从集合中找出包含枸杞的数据并删除它
/*
for(int i=0;i<list.size();i++){
//1 = 0 1 2 3 4 5
//取出当前遍历到的数据
String ele = list.get(i);
//判断这个数据中包含枸杞
if(ele.contains("枸杞")){
//直接从集合中删除该数据
list.remove(ele);
}
}
System.out.println(list);
*/
//方式一:每次删除一个数据后,就让i往左退一步
/*
for(int i=0;i<list.size();i++){
//1 = 0 1 2 3 4 5
//取出当前遍历到的数据
String ele = list.get(i);
//判断这个数据中包含枸杞
if(ele.contains("枸杞")){
//直接从集合中删除该数据
list.remove(ele);
i--;
}
}
System.out.println(list);
*/
//方式二:从集合的后面倒着遍历并删除
//[Java入门, 宁夏枸杞, 黑枸杞, 人字拖, 特级枸杞, 枸杞子]
// i
for(int i=list.size()-1;i>=0;i--){
//取出当前遍历到的数据
String ele = list.get(i);
//判断这个数据中包含枸杞
if(ele.contains("枸杞")){
//直接从集合中删除该数据
list.remove(ele);
}
}
System.out.println(list);
}
}
ArrayList综合案例
package com.itheima.arraylist;
public class ArrayListTest2 {
public static void main(String[] args) {
//完成案例:商家菜品上架工作
//1.要设计菜品对象首先应该设计菜品类;设计菜品类Food负责创建菜品对象,封装菜品数据
//2.设计一个菜品操作类FoodOperator,负责完成对菜品的业务实现:上架,浏览信息
FoodOperator operator = new FoodOperator();
operator.start();
}
}
package com.itheima.arraylist;
public class Food {
private String name;
private double price;
private String desc;//描述
public Food() {
}
public Food(String name, double price, String desc) {
this.name = name;
this.price = price;
this.desc = desc;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}
package com.itheima.arraylist;
import java.util.ArrayList;
import java.util.Scanner;
//菜品操作类:负责上架和浏览功能的实现
public class FoodOperator {
//1.定义一个ArrayList集合对象,负责存储菜品对象信息
private ArrayList<Food> foodList = new ArrayList<>();
//foodList=[]
//2.开发功能:上架菜品功能
public void addFood(){
//3.创建一个菜品对象,封装上架的菜品信息
Food f = new Food();
//4.录入菜品信息进去
Scanner sc = new Scanner(System.in);
System.out.println("请您输入该菜品名称:");
String name = sc.next();
f.setName(name);
System.out.println("请您输入该菜品价格:");
double price = sc.nextDouble();
f.setPrice(price);
System.out.println("请您输入该菜品描述:");
String desc = sc.next();
f.setDesc(desc);
//5.把菜品对象存入到集合中去
foodList.add(f);
System.out.println("上架成功!");
}
//6.展示菜品
//foodList = [f1,f2,...]
public void showAllFoods(){
if(foodList.size()==0) {
System.out.println("什么菜品都没有,先去上架!");
return;//拦截
}
for(int i=0;i<foodList.size();i++){
Food f=foodList.get(i);
System.out.println(f.getName());
System.out.println(f.getPrice());
System.out.println(f.getDesc());
System.out.println("------------------------------");
}
}
//负责展示操作界面
public void start(){
while(true) {
System.out.println("请选择功能:");
System.out.println("1.上架菜品");
System.out.println("2.展示菜品");
System.out.println("2.退出");
Scanner sc = new Scanner(System.in);
System.out.println("请选择您的操作:");
String command = sc.next();
switch (command) {
case "1":
addFood();
break;
case "2":
showAllFoods();
break;
case"3":
System.out.println("下次再来哦!");
return;//干掉方法!
default:
System.out.println("您输入的命令不存在");
}
}
}
}
Day2 面向对象高级一
static
静态,可以修饰成员变量,成员方法
static修饰成员变量
package com.itheima.staticdemo;
public class Student {
//类变量
static String name;
//实例变量(对象的变量)
int age;
}
package com.itheima.staticdemo;
public class Test {
public static void main(String[] args) {
//1.类变量的用法
//类名.类变量(推荐)
Student.name="袁华";
//对象.类变量(不推荐)
Student s1 = new Student();
s1.name = "马冬梅";
Student s2 = new Student();
s2.name="秋雅";
System.out.println(s1.name);//秋雅
System.out.println(Student.name);//秋雅
//2.实例对象的用法
//对象.实例变量
s1.age=23;
s2.age=18;
System.out.println(s1.age);
}
}
static修饰成员方法
package com.itheima.staticdemo2;
public class Student {
double score;
//类方法
public static void printHelloWorld(){
System.out.println("Hello World");
}
//实例方法(对象的方法)
public void printPass(){
System.out.println("成绩:"+(score >= 60 ? "及格" : "不及格"));
}
}
package com.itheima.staticdemo2;
public class Test {
public static void main(String[] args) {
//1.类方法的用法
//类名.类方法(推荐)
Student.printHelloWorld();
//对象.类方法(不推荐)
Student s = new Student();
s.printHelloWorld();
//2.实例方法的用途
//对象.实例方法
s.printPass();
}
}
static修饰类方法的应用场景-工具类
为什么工具类中的方法要用类方法,而不用实例方法
-
实例方法需要创建对象来调用,对象占内存,会浪费内存
-
类方法直接用类名调用即可,节省内存
static注意事项
-
类方法中可以直接访问类的成员,但不可以直接访问实例成员
-
实例方法中既可以直接访问类成员,也可以直接访问实例成员
-
实例方法中可以出现this关键字,类方法中不可以出现this关键字
继承
继承的特点
子类能继承父类的非私有成员(成员变量、成员方法)
继承后对象的创建
子类的对象由子类、父类共同完成的,子类、父类对外暴露什么成员,对象就可以访问什么成员
继承的好处
继承:权限修饰符
继承注意事项
-
Java是单继承的:一个类只能继承一个直接父类;Java中的类不支持多继承,但支持多层继承
多继承:class 子类 extends 父类A,父类B{ }
-
Object类是Java中所有类的祖宗
Object类
class A{} 默认 extends Object{}
我们写的任何一个类,其实都是Object的子类或子孙类
方法重写
声明不变,重新实现
当子类觉得父类中的某个方法不好用,或者无法满足自己的需求时,子类可以重写一个方法名称、参数列表一样的方法,去覆盖父类的这个方法
重写后,方法的访问, Java会遵循就近原则
方法重写注意事项
方法重写的应用场景
子类中访问其他成员的特点
在子类方法中访问其他成员(成员变量、成员方法),是依照就近原则的
成员变量
成员方法
super关键字,指定访问父类的成员:super.父类成员变量/父类成员方法
子类构造器的特点
子类的全部构造器,都会先调用父类的构造器,再执行自己
子类构造器是如何实现调用父类构造器的
-
默认情况下,子类全部构造器的第一行代码都是super(),它会调用父类的无参数构造器
-
如果父类没有无参数构造器,我们必须在子类构造器的第一行手写super(...),指定去调用父类的有参数构造器
子类构造器调用父类构造器的应用场景
this(...)调用兄弟构造器
任意类的构造器中,是可以通过this(...)去调用该类的其他构造器的
Day3 面向对象高级二
多态
多态是继承/实现情况下的一种现象,表现为:对象多态、行为多态
行为多态:都是同一行为但是表现出不同的状态 eg.学生跑的快,老师跑的慢 识别技巧:编译看左边,运行看右边
对象多态:都是同一对象但是表现出不同的角色 eg.人既可以是学生对象;也可以是老师对象
变量不讲多态性,所以编译看左边,运行看左边
多态下的类型转换
强转可以解决:多态下不能调子类独有功能的问题
final
可以修饰类、方法、变量
-
final修饰类,类不能被继承
-
final修饰方法,方法不能被重写
-
fianl修饰变量,只能赋值一次
抽象类
抽象类的注意事项、特点
-
抽象类中可以不写抽象方法,但有抽象方法的类一定是抽象类
-
类该有的成员(成员变量、方法、构造器)抽象类都可以有
-
抽象类不能创建对象,仅作为父类让子类继承
-
一个类继承了抽象类,必须重写完抽象类的全部抽象方法,否则自己也要是抽象类
抽象类的场景和好处
或
接口
格式:
public interface 接口名{
//成员变量(默认是常量)
//成员方法(默认是抽象方法)
}
接口不能创建对象
extends理解成亲爹;implements理解成干爹
alt+回车 选implement methods 就可以接口里的全部抽象方法都实现
接口的好处
可以解决类单继承的问题,通过接口,我们可以让一个类有一个亲爹的同时,还可以找多个干爹去扩展自己的功能
JDK8开始,接口新增的三种方法
接口的多继承
一个接口可以同时继承多个接口
public interface C extends B,A{}