1.对象的this引用
this引用用于区分成员变量和局部变量，this引用的一定的指的是成员变量
所以说this语句的作用就是区分成员变量和局部变量（如何呢）
package com.temo.test1;
public class student{
private String name;//成员变量
private int age;
public student(){
}
public student(String name,int age)//构造方法
{
this.name=name;
this.age=age;
}
//操作
public void setName(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age=age;
}
public int getAge(){
return age;
}
}2.构造器
[修饰符] 类名 （参数）
这种形式就是构造器，构造器的名字一定要为类名！！！！！
构造器的重载：
带参数构造器和无参数构造器
亮着方法名虽然相同，但是参数名不同，这叫构造方法的重载
public class user {
private String name;//成员变量
private String passward;
private String email;
private String sex;
private int age;
public user() {//无参构造器
}
public user(String name, String passward, String email, String sex, int age) {
//有参构造器
this.name = name;
this.passward = passward;
this.email = email;
this.sex = sex;
this.age = age;
}
// //操作
// public void setName(String name){
// this.name=name;
// }
// public String getName(){
// return name;
// }
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassward() {
return passward;
}
public void setPassward(String passward) {
this.passward = passward;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}3.继承
继承的概念
1.继承的定义：
子类继承父类（父亲和孩子的关系）
1.public class 子类 extends 父类{ }
2.Java是一种纯粹的面向对象的语言，声明的所有类默认是继承Object类，它是所有的java类的根
3.Java是单根继承关系（一脉相传），保证纯正的血统
4.子类会拥有父类的一些特征
2.继承关系的特点
1.子类如果实例化，那么父类的构造方法会被先调用
2.子类可以调用父类的public方法，私有方法是不能调用的
3.子类的功能是在继承关系中最强大的
public class Person extends MonkeyMan{
public Person(){
System.out.println("人");
}
public void clothes(){
System.out.println("人会穿衣服");
}
public void paint(){
System.out.println("人会画画");
}
public static void main(String[] args) {
Person person = new Person();
person.walk();
person.useTools();
}
}4.多态
Java中的多态
在Java中，多态是指同一名称的方法可以有多种实现（方法实现是指方法体）。系统根据调用方法的参数或调用方法的对象自动选择某一个具体的方法实现来执行。多态亦是面向对象的核心特征之一。
多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们可以通过相同的方式予以调用
package com.codeke.java.test;
/**
* 动物类
*/
public class Animal {
// 属性
private String type; // 类型
private String breed; // 品种
private String name; // 名称
/**
* 构造函数（明确知道类型、品种、名称）
* @param type 类型
* @param breed 品种
* @param name 名称
*/
public Animal(String type, String breed, String name) {
this.type = type;
this.breed = breed;
this.name = name;
}
/**
* 构造函数（只知道类型和名称，但是品种未知）
* @param type 类型
* @param name 名称
*/
public Animal(String type, String name) {
this.type = type;
this.name = name;
this.breed = "未知";
}
/**
* 构造函数（只知道名称，但是类型和品种都未知）
* @param name 名称
*/
public Animal(String name) {
this.name = name;
this.type = "未知";
this.breed = "未知";
}
}
5.每日一题
小黑的鸡脚plus
这题是一道动态规划类的题目，但是有些隐晦，其实写多了就好想了，我们首先定义dp数组的含义，dp[i][j]指的是在前i个数，用了j次翻转机会，得到的完美串数，然后就写出动态转移方程即可
dp[i][j]=dp[i-1][j];
if(i>=d)
{
ans=sum[i]-sum[i-d];
if(j>=ans)
{
dp[i][j]=max(dp[i][j],dp[i-d][j-ans]+1);
}
}AC代码
#include <iostream>
#include <cstring>
using namespace std;
int t,k,d;
char s[2005];
int sum[2005];
int dp[2005][105];
long long ans;
int main()
{
cin>>t;
while(t--)
{
memset(sum,0,sizeof(sum));
memset(dp,0,sizeof(dp));
cin>>k>>d;
cin>>s;
int n=strlen(s);
for(int i=1;i<=n;i++)
{
if(s[i]=='0')
{
sum[i]=sum[i-1]+1;
}
else
sum[i]=sum[i-1];
}
for(int i=1;i<=n;i++)
{
for(int j=0;j<=k;j++)
{
dp[i][j]=dp[i-1][j];
if(i>=d)
{
ans=sum[i]-sum[i-d];
if(j>=ans)
{
dp[i][j]=max(dp[i][j],dp[i-d][j-ans]+1);
}
}
}
}
printf("%d\n",dp[n][k]);
}
return 0;
}6.学习计划
4.1日将进行抽象类，以及接口的学习，了解抽象类的作用以及抽象方法，深入了解接口的继承与使用，
4.2日将进行内部类的学习和lambda表达式，了解非静态和静态的内部列，任何学会使用，以及能够运用局部内部类，然后labda表达式进行与函数式接口的结合，了解到lambda表达式调用Arrays的、类方法，同时也将进行枚举类的学习（如果课程很多，则将在4.3日内继续进行学习）
4.3日就是对象与垃圾回收，以及JAR文件学习，同时初步认识java基础类库
